Coding Interview Questions and Answers for 2026

In the case of the insertion sort algorithm, we divide the array into two parts: sorted array and unsorted array. Then from the unsorted array, we pick the first element and find its correct position in the sorted array. We repeat the process until there are no items left in the unsorted part of the array. The pseudocode for the insertion sort algorithm is – 

1. Step 1: INITIALIZE an array. 
2. Step 2: ITERATE through the index positions 1 to the end of the array. 
3. Step 3: ASSIGN the key to the current index position. The elements at the left of this index position are part of the sorted array while the elements to the right are considered part of the unsorted array. 
4. Step 4: CHECK if the element to the left of the current index is greater than the number. If true, then swap the positions. REPEAT this until we reach a value smaller than the current index or index position 0. 

The python program for the insertion sort is – 

arr = [56, 63, 84, 90, 15, 38, 22, 5, 71, 49] 
arr_length = len(arr) 
for i in range(1, arr_length): 
key = arr[i] 
j = i - 1 
while key < arr[j] and j >= 0: 
arr[j+1] = arr[j] 
j -= 1 
arr[j+1] = key 
print('Sorted array:', arr) 

The output of the program is “Sorted array: [5, 15, 22, 38, 49, 56, 63, 71, 84, 90]”.

OOP stands for Object Oriented Programming. It is a way of writing code which involves classes, methods, attributes, and objects instead of traditional functions. Large, sophisticated, and actively updated or maintained programs are best fit for this method of development. The use of objects allows the creation of multiple unique instances of a class and the reuse of the methods and attributes of the class, thereby, improving code efficiency, reusability, and readability. The building blocks of OOP are –  

• Classes – It is a user-defined data type which contains the attributes and methods. 
• Objects – It is an instance of a class. Each object holds the data information uniquely within itself. 
• Methods – It is a function written within a class. These functions can be accessed through the objects. 
• Attributes – It is defined as property variables for a class. These can be accessed using the objects of the class. The value of the attributes might differ from object to object. 

The main concepts of OOP include – 

• Inheritance – Inheritance allows using the attributes and methods from the parent class within the child class. For example, a Vehicle class will have attributes such as top speed, mileage, manufacturing date, etc., and methods such as applying brakes, pressing the horn, etc. These attributes and methods apply to any kind of Vehicle; therefore, Bike and Car classes can inherit from the parent class, Vehicle, enabling them to use the defined attributes and methods in the Vehicle class. 
• Abstraction – Abstraction helps to understand an underlying property of a class without exposing the internal details of the application. For example, if the Vehicle class is made as the abstraction class, then we can hide the logic behind apply brakes method. This will ensure that the user knows that this method will apply the brakes but does not learn about its internal working of it. 
• Polymorphism – Polymorphism refers to having many forms. It can define various forms in which an object can be accessed. 
• Encapsulation – Encapsulation adds security by avoiding exposing the information contained within an object to other objects. Therefore, an object’s data remains private and other objects cannot access this data. 

Method overriding is an example of runtime polymorphism. Method overriding is implemented during inheritance that involves declaring the same method in the child class which can be found in the parent class. By doing this, we can use the method of the child class instead of the parent class whenever the object of the child class calls the method. Let us understand this with the help of an example. 

class Parent: 
def foo(self): 
print(‘Parent foo called’) 
class Child1(Parent): 
def foo(self): 
print(‘Child1 foo called’) 
class Child2(Parent): 
pass 
c1 = Child1() 
c1.foo() 
c2 = Child2() 
c2.foo() 

In the code, we have implemented three classes – one parent class and two child classes. In the parent class, we have a method named ‘foo’. Both the child classes – Child1 and Child2 inherit from the parent class. The Child1 class has its implementation of the ‘foo’ method. The Child2 class does not have its own ‘foo’ method. After we run the program, we will see that if the child class has its implementation of the parent class methods, then it will override it. Therefore, calling the ‘foo’ method using the Child1 class object will result in overriding the parent class method and calling the ‘foo’ method using the Child2 class object will call the parent class ‘foo’ method since it has not overridden the method. The output of the program is – 

Child1 foo called 
Parent foo called 

A thread is a lightweight process that is responsible to run a single sequential program. A sequential program has a beginning, a sequence, and an end. For example, consider a sorting program which has a beginning, an execution sequence, and an end which indicates that the sorting is complete. A thread runs within a program and shares its resources for execution. However, most applications like to take advantage of the multithreading architecture which is capable of running multiple threads at the same time and performing different tasks in the same program. For example, when you are working with MS Word, you can see the highlights which lets you quickly look at your typing errors. It can even run 3rd party add-ons that can help you with other tasks such as identifying grammatical mistakes, inserting pictures, etc. While working with resource-intensive applications, it is recommended to use the concepts of multi-threading to take advantage of the resources, thereby, allowing your application to run smoothly. However, multi-threading is a diverse topic and a tricky one to implement, therefore, one needs to consider using the right set of available libraries to implement it.  

Time complexity refers to the time taken by a program to complete its execution. It is measured using the Big O notation. Big O notation is a language and a metric that is used to describe the efficiency of algorithms. Without understanding Big O notations, it is not possible to create efficient algorithms. If we don’t know when our algorithm gets faster or slower, we’ll struggle to judge our program performance. This concept gives us one way of describing how the time it takes to execute our program grows as the size of input grows. For example, a sorting algorithm might be quicker to sort a smaller array but as the size of the array increases, the time taken to sort the array using the same algorithm might increase drastically. In such cases, other sorting algorithms might turn out to be useful.

Time is not the only thing that matters in an algorithm. We might also care about the amount of memory or the space that is being consumed by the algorithm or the program. It is a parallel concept to time complexity. Space complexity is the measure of the amount of working storage that a program needs. As with time complexity, here we are concerned with how the space that is needed grows as the size of the input grows. For example, a smaller array will consume a lesser space than compared to a larger array. If you are using too many variables to store intermediate computations in your program then you might end up consuming more space.

Fibonacci sequence is the sequence of whole numbers 0,1, 1, 2, 3, 5, 8, ... which starts with 0 and 1, and where every number thereafter is equal to the sum of the previous two numbers. 

The pseudocode for the program is – 

• Step 1: CALL the fib function and pass the argument ‘n’. 
• Step 2: CHECK if the number ‘n’ is less than 2. If true, return the number ‘n’. 
• Step 3: RETURN the summation of CALL to fib function with ‘n-1’ and ‘n-2’ parameters respectively. 

The python implementation for the same is – 

def fib(n): 
if n < 2: 
return n 
return fib(n - 1) + fib(n - 2) 
print('Fibonacci for n=8 is', fib(8)) 

The output of the program is “Fibonacci for n=8 is 21”.

Inheritance is a way to form new classes using classes that have already been defined. Important benefits of inheritance are the ability to reuse code and make the program more readable. To further understand inheritance consider the following example: 

class Vehicle: 

def __init__(self, mileage, no_of_wheels): 
self.mileage = mileage 
self.no_of_wheels = no_of_wheels 
def apply_brakes(self): 
print('Brakes applied.') 
def press_horn(self): 
print('Honkingggg!!!!!') 

class Bike(Vehicle): 

def __init__(self, mileage): 
super().__init__(mileage, no_of_wheels = 2) 
# Creating an instance of a Bike class 
bike_obj = Bike(mileage = 60) 
# Accessing attributes instantiated in Parent class 
print('Mileage:', bike_obj.mileage) 
print('No of wheels:', bike_obj.no_of_wheels) 
# Accessing methods instantiated in Parent class 
bike_obj.apply_brakes() 
bike_obj.press_horn() 

The output of the program is – 

Mileage: 60 
No of wheels: 2 
Brakes applied. 
Honkingggg!!!!! 

In the python code, we have created a parent class, Vehicle, and a child class, Bike (inheriting from the parent class). The parent class, Vehicle, has two attributes, namely, ‘mileage’ and ‘no_of_wheels’. It also has two methods, namely, ‘apply_brakes()’ and ‘press_horn()’. In the child class, Bike, there are no attributes or methods defined but since we are inheriting the parent class, we can use all the methods and attributes of the parent class. We have created the attribute of the child class and accessed the above-mentioned attributes and methods as seen in the output. 

A regular expression, or simply regex, allows us to look for general patterns in text data. For example, if we are looking for an email or phone number in a large document then we can define the pattern and extract all the available emails and phone numbers present in the document using regex. Regular expressions have a standardized set of rules for defining the pattern irrespective of the programming language. They are used widely and are an extremely powerful way to work with text data. Using some of these rules, we can define the phone pattern in regular expression as –

^[6-9]\d{9}$

The ‘^’ marks at the beginning should be with the characters present in the square bracket where 6-9 means any number out of 6, 7, 8, and 9. These four numbers should be present in just one. Following this ‘\d’ means any digit and ‘{9}’ means repeated exactly 9 times. Therefore, the complete pattern describes that the matching string should start with a number 6, 7, 8, or 9 followed by 9 other digits, totalling 10 digits of a phone number.

Tree data structures are a form of non-linear data structure. With an increase in the number of data points, linear data structures are found to be more time-consuming. To avoid this time complexity, tree data structures can play a role. These are tree-like structures formed using nodes, roots, and edges. Since it is a non-linear data structure type, it has a multi-level hierarchy as shown below –

• Node is an entity which contains a value along with the reference to its child nodes (Node 1-9 in the figure).
• Root is the topmost node in a tree (Node 1 in the figure).
• Leaf is the deepest node which does not have any further child nodes (Node 4, 5 6, 7, 8, 9 in the figure).
• Edge is the link or relationship between two nodes.
• Depth of a node defines the number of edges from the root node to the node (The depth of node 9 and node 7 are 3 and 2 respectively).
• Height of a node is the number of edges from the node to the leaf node (The height of nodes 9 and 3 are 0 and 1 respectively).

In essence, a binary search tree is just a binary tree with extra features. The first characteristic is that the value of the node in the left subtree is lower than or equal to the value of its parent node. The value of the node in the right subtree exceeds the value of its parent node. Here is an illustration of a binary tree.

The root node of the example binary tree is node 56. For the first property, we stated that the value of the node in the left subtree is less than or equal to the root node. You can see that in this instance, 49 is less than 56. Now, we should have a node in the right subtree that is higher than the value of the root node. You can see that 63 is greater than 56 in this situation. We can observe that this attribute follows the same pattern down to the leaf node if we continue to assess it farther into the tree.

There is no index of the data elements stored in the binary search tree. As a substitute, it uses an implicit structure to keep track of each element's location. The addition and deletion of nodes may be accomplished fast due to this structure. In contrast to how we operate with arrays, where we must progressively tour each element until the correct one is located, in this case, we only need to walk the half tree. Next, we go on to the other tree's half. This produces the desired effect considerably more quickly than a straight loop would. Because a binary search tree is quicker than a binary tree, we could need one while sorting data.

The binary search algorithm searches the required element in the array by dividing the array into two parts. The algorithm can only be applied to an array which is already sorted. It can be implemented using two different approaches, namely, the iterative method and the recursive method. The underlying algorithm remains the same in both methods which work on the principle of ‘divide and conquer’. The iterative method has a complexity of O(1) whereas the recursive method has a complexity of O(log n) which makes the iterative method more efficient.

The pseudocode for implementing a binary search algorithm is –

• Step 1: INITIALIZE the array.
• Step 2: INITIALIZE the number whose index position needs to be found, say x.
• Step 3: DECLARE two pointers equal to index position 0 (say start) and last index (say end) in the array.
• Step 4: EVALUATE the central index position in the array.
• Step 5: CHECK if x is equal to the element at the central position. If true then return the index position and stop.
• Step 6: CHECK if x is greater than the number at the central index it means that x is present at the right half of the array. Shift the start index to the central index position + 1.
• Step 7: CHECK if x is smaller than the number at the central index it means that x is present at the left half of the array. Shift the end index to the central index position.
• Step 8: REPEAT steps 4 to 7 until x is found in the array.

The python implementation for the same is –

# Initialize the array 
arr = [5, 15, 22, 38, 49, 56, 63, 71, 84, 90] 
# Define the search element 
x = 22 
# Calculate the length of the array 
arr_length = len(arr) 
# Assign start and end index positions 
start = 0 
end = arr_length - 1 
while start <= end:  
# Compute the middle index position 
mid = start + (end - start)//2 
# Check if the element is in the middle position 
# Else reassign new start and end index positions 
if arr[mid] == x: 
idx = mid 
break 
elif arr[mid] < x: 
start = mid + 1 
else: 
end = mid - 1 
print(f"Index position for element {x} is", idx) 

The output of the program is “Index position for element 22 is 2”.

The flowchart to find the smallest number in an integer array can be given as –

The python implementation for the same is –

# Initialize the array 
arr = [56, 63, 84, 90, 15, 38, 22, 5, 71, 49] 
# Calculate the length of the array 
N = len(arr) 
i = 0 
# Assign the random smallest number at the start of the index position 
result = arr[0] 
while i < N: 
# Check if the current element is smaller than the result 
if arr[i] < result: 
result = arr[i] 
# Increment the current index position 
i += 1 
print("Smallest element in the array is", result) 

The output of the program is “Smallest element in the array is 5”.

The flowchart to find the missing number in an integer array can be given as –

# Initialize the array 
arr = [1, 1, 2, 2, 4, 5, 8, 9] 
# Sort the array 
arr.sort() 
# Calculate the length of the array 
N = len(arr) 
# Initialize a new array with length N and 0 elements 
narr = [0]*N 
# Mark the indexes as 1 if the item is present 
for i in range(0, N): 
if i + 1 in arr: 
narr[i] = 1 
print('The missing elements are:') 
# Print the indexes where the element is still 0 
for i in range(0, N): 
if narr[i] == 0: 
print(i + 1) 

The output of the program is – 

The missing elements are: 
3 
6 
7 

Multiplication of two matrices is only possible if the number of columns of the first matrix matches the number of rows of the second matrix. That means we can multiply the i x j matrix with j x k. The pseudocode for multiplying two matrices is given as (assuming we are multiplying i x j matrix with j x k) – 

• Step 1: ASSIGN both the matrices (say A and B) 
• Step 2: DECLARE i, j, k 
• Step 3: INITIALIZE a zero matrix ‘result’ with i rows and k columns 
• Step 4: FOR x = 0 to x = i – 1 
• Step 5: FOR y = 0 to y = k – 1 
• Step 6: FOR z = 0 to z = j – 1 
• Step 7: ASSIGN result[x][z] = result[x][z] + A[x][z] * B[y][z] 

The implementation in python language for the same is – 

# Initialize matrix A 
A = [ 
[22, 18, 5], 
[9, 15, 31], 
[12, 14, 25], 
] 
# Initialize matrix B 
B = [ 
[16, 8], 
[3, 0], 
[9, 11], 
] 
# Initialize i, j, k 
i = len(A) 
j = len(A[0]) 
k = len(B[0]) 
# Initialize resultant matrix 
result = [[0,0], [0,0], [0,0]] 
for x in range(0, i): 
for y in range(0, k): 
for z in range(0, j): 
result[x][y] += A[x][z] * B[z][y] 
for row in result: 
print(row) 

The output of the program is – 

[451, 231] 
[468, 413] 
[459, 371] 

To swap two integer variables, we can use the addition (+) and subtraction (-) operators between the variables. Consider the two integer variables are x and y then we can swap them using –

x = x + y 
y = x – y 
x = x - y 

In this case, we first added the two integers x and y, and then stored them in x. We then assign x – y to y but x here is equal to x + y which means that we are assigning y = x – y = (x + y) – y = x. Next, we assign x as x – y where we are performing x = x – y = (x + y) – (x) = y. Therefore, by using some mathematical calculations we can swap two integer variables without using a temporary variable.

The merge sort algorithm is a ‘divide and conquer’ algorithm. In the "divide and conquer algorithm," a large problem is divided into smaller chunks, and when those chunks are so small that more division is impossible, we start merging them to find the solution. The input array is split in half and then repeatedly halved until no further division is possible. We begin merging them with sort order once the halving is complete. Finally, we reach the final answer in which we sort all elements. For example, let us consider the array [56, 63, 84, 90, 15, 38, 22, 5, 71, 49]. The split can be performed as –

After splitting the array in half, we divided the two resulting chunks in half once more to create four chunks. We continued splitting these chunks until we ran out of methods to do so. The next step is to merge these chunks (starting from the bottom) which are nothing but arrays consisting of a single item. We'll make sure that each split array is now ordered during merging.The items were placed differently from the prior merge, as indicated by the orange places. Only the components with values 22 and 38 were shuffled during the initial merge. Three of the four arrays underwent shuffling during the second merge. During the third merge, one of the two arrays underwent shuffling. The sorted array is created by the last merge.

Sorting algorithms are divided into two categories based on the space they use and the stability of the algorithms. Based on stability, algorithms can further be classified into stable or unstable. 

Stable sorting is the term for a sorting algorithm that does not alter the order in which related pieces of content appear after the content has been sorted. Consider an array with the repeating element "22," where the first instance is stored at memory address "x0001" and the second instance is placed at location "x0002" in the memory. The element "22" will preserve this order in stable sorting, meaning that the first instance of 22 in the sorted array is the one that occupied location "x0001," and the second instance is at position "x0002." In this case, memory is only being taken into account to discriminate between these two items that share the same value. 

On the other hand, a sorting algorithm is said to be unstable if, after sorting the content, it changes the order in which related content appears. Therefore, if we use the same array, sorting will place the element "22" at position "x0002" ahead of the similar element at position "x0001" in the sequence.

The algorithms can be classified into – 

• Simple recursive algorithms – It functions similarly to iterative algorithms, but in this case, the recursion mimics a loop; that is, the algorithm repeatedly invokes itself. 
• Dynamic algorithms – They employ memorization, which implies that they keep track of previous outcomes and use them to generate future outcomes. These algorithms are typically employed for optimisation problems. The objective is to select the best option from a variety of options. For instance, determining the fastest route under specific circumstances.  
• Greedy algorithms – To discover the optimal answer to optimization issues, these algorithms are also used. It operates in stages. We pick the best available at each stage without considering the repercussions in the future (thus the term "greedy"), and we anticipate that by selecting a locally optimal solution at each stage, we will arrive at a globally optimal solution. 
• Divide and conquer algorithms – There are two parts to the divide and conquer algorithm. The problem is broken down into smaller, related subproblems in the first section, and these are then solved recursively. The second component is that it incorporates the answers to the subproblems into the answer to the main problem. If an algorithm has at least two recursive calls, it is typically referred to as divide and conquer. Using the divide and conquer method, we can discover certain sorting algorithms. 
• Brute force algorithms – This method merely tests every possibility until a workable solution is discovered. Identifying the password combination, for instance. 
• Randomized algorithms – At least once throughout the tournament, these methods use a random number to choose the winner. 

We need to first check if the lines are parallel or not. If they are parallel then there is no point of intersection. If they are not parallel, we can find their intersection points. The pseudocode for the program is given by – 

• Step 1: ASSIGN the coordination for both the lines 
• Step 2: GENERATE the line equation for the first line 
• Step 3: GENERATE the line equation for the second line 
• Step 4: CALCULATE the determinant value 
• Step 5: CHECK IF the determinant is equal to 0. If yes, then DISPLAY that the lines are parallel and exit. 
• Step 6: CALCULATE x and y which are the points of intersection. 

The implementation in python language for the same is – 

# Assign coordinates for line AB and CD 
A = (-5, -1) 
B = (3, 3) 
C = (1, 2) 
D = (-2, -3) 
# Generate the line equation for line AB 
a1 = B[1] - A[1] # y2 - y1 
b1 = A[0] - B[0] # x1 - x2 
c1 = a1*A[0] + b1*A[1] 
# Generate the line equation for line CD 
a2 = D[1] - C[1] # y2 - y1 
b2 = C[0] - D[0] # x1 - x2 
c2 = a2*C[0] + b2*C[1] 
# Calculate the determinant 
det = a1 * b2 - a2 * b1 
if det == 0: # Alternatively, check for a1/b1 == a2/b2 
print('Lines AB and CD are parallel') 
else: 
# Calculate x 
x = (b2 * c1 - b1 * c2) / det 
# Calculate y 
y = (a1 * c2 - a2 * c1) / det 
print(f'Points AB and CD are intersecting at ({x}, {y})', ) 

The output of the program is “Points AB and CD are intersecting at (1.0, 2.0)”.

We must comprehend the ideas of backtracking and recursion to put this programme into practice. Recursion plays a crucial role in backtracking. Backtracking is a general algorithm approach that takes into account looking through every potential combination to solve the computing problem and its type of recursion. A backtracking algorithm is a problem-solving algorithm that finds the desired result by applying a brute force method. The brute force method tests every potential solution before selecting the ideal one. But take note that it can often exclude a huge number of candidates with a single test, making it much faster than the brute force enumeration of all complete candidates. Backtracking is done when there are several solutions and we want all of them so we can eliminate several undesirable states in a single iteration.

Enumeration, optimization, and decision problems can all be solved through backtracking.

The implementation of the program to find all permutations of a string is a classic example of backtracking and can be implemented in python as –

# Convert the array to a string 
def arr_to_str(arr): 
return ''.join(arr) 
# Convert string to an array 
def str_to_arr(string): 
return list(string) 
# Function to find all permutations of an array  
def permute(arr, idx, length): 
if idx == length: 
print(arr_to_str(arr)) 
for i in range(idx, length): 
# Performing swapping 
temp = arr[idx] 
arr[idx] = arr[i] 
arr[i] = temp 
# Recursively calling the function permute 
permute(arr, idx + 1, length) 
# Performing swapping (Backtracking) 
temp = arr[idx] 
arr[idx] = arr[i] 
arr[i] = temp 
string = "cat" 
arr = str_to_arr(string) 
arr_length = len(arr) 
permute(arr, idx = 0, length =arr_length) 

The output of the program is –

cat 
cta 
act 
atc 
tac 
tca