80+ Flipkart Software Developer Interview Questions and Answers

Implement a search function to find a specified integer in a rotated sorted array.

• Implement a binary search algorithm to find the target integer in the rotated sorted array.

• Handle the cases where the target integer may lie in the left or right half of the array after rotation.

• Keep track of the mid element and adjust the search space based on the rotation.

• Return the index of the target integer if found, else return -1.

Find the missing integer in binary form from an array of unique binary strings.

• Iterate through the array of binary strings and convert each string to its decimal equivalent.

• Calculate the sum of all integers from 0 to N using the formula (N * (N + 1)) / 2.

• Subtract the sum of the integers represented by the binary strings from the total sum to find the missing integer.

• Convert the missing integer to binary form and return it as a string without leading zeros.

Find the smallest substring in S containing all characters in X.

• Use a sliding window approach to find the smallest window in S containing all characters in X.

• Keep track of the characters in X using a hashmap.

• Slide the window to the right until all characters in X are found, then shrink the window from the left to find the smallest window.

Calculate and return the median of all subarrays of a specified size in an integer array.

• Iterate through the array and for each subarray of size M, calculate the median.

• If the size of the subarray is even, take the average of the two middle numbers as the median.

• Return the list of medians for all subarrays of size M.

Find the k-th smallest element in an unsorted array of distinct integers.

• Sort the array and return the k-th element.

• Use a priority queue or quickselect algorithm for efficient solution.

• Handle edge cases like k being out of bounds or array being empty.

Count the total number of nodes in a complete binary tree given its root.

• Traverse the tree in level order and count the nodes

• Use a queue to keep track of nodes at each level

• Check for null nodes represented as -1 in the input

• Return the total count of nodes in the tree

Find the length of the longest substring without repeating characters in a given string.

• Use a sliding window approach to keep track of the longest substring without repeating characters.

• Use a hashmap to store the index of each character as it appears in the string.

• Update the start index of the window when a repeating character is found.

• Calculate the maximum length of the window as you iterate through the string.

• Return the maximum length as the result.

The task is to compute the shortest path from node '0' to each node in a directed graph with alternating colored edges.

• Create a graph using the given red and blue edges.

• Use Breadth First Search (BFS) to find the shortest path from node '0' to each node with alternating colored edges.

• If no such path exists, set the length to -1.

• Return the array of shortest path lengths for each node.

Implement counting sort algorithm to sort an array of integers without comparisons.

• Count the frequency of each element in the input array.

• Calculate the prefix sum of frequencies to determine the position of each element in the sorted array.

• Build the sorted array based on the prefix sum.

• Time complexity of counting sort is O(n+k), where n is the number of elements and k is the range of input.

• Example: Input array {-2, 1, 2, -1, 0} will be sorted as {-2, -1, 0, 1, 2}.

Detect if an array contains a Pythagorean triplet by checking if there are three integers x, y, and z such that x^2 + y^2 = z^2.

• Iterate through all possible triplets of numbers in the array and check if they form a Pythagorean triplet.

• Use a nested loop to generate all possible combinations of three numbers from the array.

• Check if the sum of squares of two numbers is equal to the square of the third number for each triplet.

• Return 'yes' if a Pythagorean triplet is found, otherw...read more

Validate if a given binary tree is a Binary Search Tree (BST) or not.

• Check if the left subtree of a node contains only nodes with data less than the node's data.

• Check if the right subtree of a node contains only nodes with data greater than the node's data.

• Recursively check if both the left and right subtrees are also binary search trees.

Implement a phone directory search feature to suggest contacts based on a query string prefix.

• Iterate through the contact list to find contacts with the prefix matching the query string.

• Display suggestions as the user types each character of the query.

• Handle cases where no suggestions are found for a particular prefix by printing 'No suggestions found'.

Reverse a singly linked list of integers and return the head of the reversed linked list.

• Iterate through the linked list and reverse the pointers to point to the previous node instead of the next node.

• Use three pointers - prev, current, and next - to reverse the linked list in O(N) time and O(1) space complexity.

• Update the head of the reversed linked list as the last node encountered during the reversal process.

Find the Kth ancestor of a given node in a binary tree.

• Traverse the tree to find the path from the target node to the root node.

• Keep track of the ancestors in a list while traversing.

• Return the Kth ancestor from the list, or -1 if it doesn't exist.

Count the number of islands in a 2D matrix of 1s and 0s.

• Use Depth First Search (DFS) or Breadth First Search (BFS) to traverse the matrix and identify connected groups of 1s.

• Maintain a visited array to keep track of visited cells to avoid revisiting them.

• Increment the island count each time a new island is encountered.

• Consider all eight possible directions for connectivity between cells.

• Handle edge cases such as out of bounds indices and already visited cells.

Add two numbers represented as linked lists and return the sum as a linked list.

• Traverse both linked lists simultaneously while adding corresponding nodes and carry over the sum if needed

• Handle cases where one linked list is longer than the other by considering carry over

• Create a new linked list to store the sum and return its head node

Find the path from a leaf node to the root node with the maximum sum in a binary tree.

• Traverse the binary tree from leaf to root, keeping track of the sum along each path.

• Compare the sums of all root-to-leaf paths and find the path with the maximum sum.

• Implement a recursive function to traverse the tree and calculate the sum of each path.

Find all distinct triplets in an array that sum up to zero.

• Use a nested loop to iterate through all possible triplets in the array.

• Sort the array to easily identify duplicates and skip them.

• Check for triplets with sum zero and add them to the result list.

Return a pointer to the middle node of a singly linked list.

• Traverse the linked list with two pointers, one moving twice as fast as the other.

• When the fast pointer reaches the end, the slow pointer will be at the middle.

• If the number of elements is even, return the second middle node.

Find the K closest points to the origin in a 2-D plane using Euclidean Distance.

• Calculate the Euclidean Distance for each point from the origin

• Sort the points based on their distances from the origin

• Return the first K points as the closest neighbors

Identify the longest palindromic substring in a given string.

• Iterate through the string and expand around each character to find palindromes

• Keep track of the longest palindrome found

• Return the longest palindrome with the smallest start index

Partition a string into palindromes and return all possible configurations.

• Use backtracking to generate all possible palindrome partitions

• Check if each substring is a palindrome before adding it to the partition

• Return all valid partitions as an array of strings

Find the minimum number of steps to reduce a positive integer to 1 using given operations.

• Use dynamic programming to keep track of minimum steps for each number from 1 to N.

• Consider all three possible operations for each number and choose the one with minimum steps.

• Handle edge cases like when N is less than 1 or when N is not a positive integer.

Find the size of the largest subtree in a binary tree that is also a Binary Search Tree.

• Traverse the tree in a bottom-up manner to check if each subtree is a BST.

• Keep track of the size of the largest BST subtree encountered so far.

• Use recursion to solve this problem efficiently.

• Example: For the input 1 2 3 4 -1 5 6 -1 7 -1 -1 -1 -1 -1 -1, the largest BST subtree has a size of 3.

Detect cycle in a directed graph using depth-first search (DFS) algorithm.

• Use DFS to traverse the graph and detect back edges (edges that point to an ancestor node).

• Maintain a visited array to keep track of visited nodes and a recursion stack to keep track of nodes in the current path.

• If a back edge is found during traversal, a cycle exists in the graph.

• Return true if a cycle is detected, false otherwise.

Design a Least Recently Used (LRU) cache data structure that supports get and put operations with capacity constraint.

• Use a combination of hashmap and doubly linked list to efficiently implement the LRU cache.

• Keep track of the least recently used item and update it accordingly when inserting new items.

• Ensure to handle the capacity constraint by evicting the least recently used item when the cache is full.

• Implement get(key) and put(key, value) operations as per the specified r...read more

Compute the skyline of given rectangular buildings in a 2D city, eliminating hidden lines and forming the outer contour of the silhouette.

• Iterate through the buildings and create a list of critical points (x, y) where the height changes.

• Sort the critical points based on x-coordinate and process them to form the skyline.

• Merge consecutive horizontal segments of equal height into one to ensure no duplicates.

• Return the final list of key points representing the skyline.

• Example: In...read more

Find the K-th smallest element in a binary search tree (BST).

• Perform an in-order traversal of the BST to get elements in increasing order.

• Keep track of the count of visited nodes to find the K-th smallest element.

• Return the K-th smallest element once the count matches K.

Determine if a robot's movement path is circular on a 2D grid given a sequence of moves.

• Create a set of directions to keep track of the robot's movement (N, E, S, W).

• Simulate the robot's movement based on the given sequence of moves.

• Check if the robot returns to the starting position after completing the moves.

Modify code to find maximum BST subtree and maximum BST tree in a given tree.

• Create a function to check if a given tree is a BST

• Traverse the tree and check if each subtree is a BST

• Keep track of the maximum BST subtree found so far

• To find maximum BST tree, check if each node can be the root of a BST

• Keep track of the maximum BST tree found so far

Calculate the total amount of rainwater that can be trapped between given elevations in an array.

• Iterate through the array and calculate the maximum height on the left and right of each bar.

• Calculate the amount of water that can be trapped at each bar by taking the minimum of the maximum heights on the left and right.

• Sum up the trapped water at each bar to get the total trapped water for the entire array.

Find the longest palindromic substring in a given string, returning the rightmost one if multiple exist.

• Use dynamic programming to check for palindromes within the string.

• Start by checking for palindromes of length 1 and 2, then expand to longer substrings.

• Keep track of the longest palindrome found and its starting index.

• Return the substring starting from the index of the longest palindrome found.

Implement a spell checker function that suggests correct spellings from a dictionary for a given query string.

• Iterate through the dictionary to check for matching prefixes with the query string.

• Return a list of suggestions if the query string is misspelled, otherwise return an empty list.

• Handle multiple test cases by looping through each case independently.

The task is to rearrange a given permutation of 'N' integers to form the lexicographically next greater permutation.

• Iterate from right to left to find the first element that is smaller than the element to its right.

• Swap this element with the smallest element to its right that is greater than it.

• Reverse the elements to the right of the swapped element to get the lexicographically next greater permutation.

The task is to find the Kth digit from the right in the number obtained from N raised to the power M.

• Iterate through the digits of N^M from right to left

• Keep track of the position of the current digit

• Return the digit at position K from the right

Algorithm to determine valid variables on a given line of code.

• Create a stack to keep track of variable declarations

• Traverse the code line by line

• When encountering a variable declaration, push it onto the stack

• When encountering a closing brace, pop all variables declared within that scope

• Return all variables still on the stack when reaching the given line number

Given a pattern and a list of words, determine if the words align with the pattern.

• Iterate through the pattern and words list simultaneously to check for alignment.

• Use a hashmap to store the mapping between characters in the pattern and words.

• Return 'True' if the mapping aligns with the order of characters in the pattern, else return 'False'.

Determine if a given binary tree is height-balanced by checking if left and right subtrees are balanced and their height difference is at most 1.

• Check if the left subtree is balanced

• Check if the right subtree is balanced

• Calculate the height difference between the left and right subtrees

• Return 'True' if all conditions are met, otherwise return 'False'

Ceil value of a key in a Binary Search Tree (BST) is found by returning the smallest integer greater than or equal to the given number.

• Traverse the BST to find the closest value greater than or equal to the key.

• Compare the key with the current node value and update the ceil value accordingly.

• Recursively move to the left or right subtree based on the comparison.

• Return the ceil value once the traversal is complete.

Design a constant time data structure to maintain mappings between keys and values with various operations.

• Use a hash table to achieve constant time complexity for INSERT, DELETE, SEARCH, and GET operations.

• Keep track of the number of key-value pairs for GET_SIZE operation.

• Check if the hash table is empty for IS_EMPTY operation.

• Return true or false for SEARCH operation based on key existence.

• Return the value associated with the key for GET operation, or -1 if not found.

Arrange balls in 4 jars to maximize probability of user losing money when drawing a red ball.

• Place all red balls in one jar and the rest in the other jars

• Ensure that the jar with red balls has the highest probability of being chosen

• Randomize the placement of the jars to add an element of chance

Find the K-th largest element in a BST.

• Perform reverse in-order traversal of the BST to find the K-th largest element.

• Keep track of the count of visited nodes to determine the K-th largest element.

• Return -1 if there is no K-th largest element in the BST.

Search for integers in a rotated sorted array efficiently.

• Use binary search to efficiently search for integers in the rotated sorted array.

• Handle the rotation of the array while performing binary search.

• Return the index of the integer if found, else return -1.

Count subarrays with sum divisible by K in an array.

• Iterate through the array and keep track of the prefix sum modulo K.

• Use a hashmap to store the frequency of each prefix sum modulo K.

• For each prefix sum, increment the count by the frequency of (prefix sum - K) modulo K.

• Handle the case when prefix sum itself is divisible by K.

• Return the total count of subarrays with sum divisible by K.

Given n sequences with start, stop and score, find maximum subset of non-overlapping sequences with maximum total score.

• Sort the sequences by their end points.

• Use dynamic programming to find the maximum sum of non-overlapping sequences.

• Keep track of the previous non-overlapping sequence with maximum sum.

• Return the maximum sum and the corresponding non-overlapping sequences.

Calculate and print the median after each new integer is added to the stream.

• Use two heaps - a max heap to store the smaller half of the numbers and a min heap to store the larger half.

• Keep the sizes of the two heaps balanced to efficiently calculate the median.

• If the total number of elements is odd, the median will be the top element of the max heap.

• If the total number of elements is even, the median will be the average of the top elements of the two heaps.

The time complexity of retrieving the minimum element from a max heap is O(1).

• Retrieving the minimum element from a max heap involves accessing the root node, which is always the minimum element in a max heap.

• Since the root node can be directly accessed in constant time, the time complexity is O(1).

Find minimum window in a string which contains all characters from another string.

• Use a sliding window approach

• Create a frequency map of characters in pat

• Iterate through str and update frequency map

• Keep track of minimum window that contains all characters

• Return minimum window

Find Pythagorean triplets in an array of integers.

• Loop through the array and pick two numbers at a time.

• Calculate the sum of squares of the two numbers.

• Check if the sum is a perfect square.

• If yes, then it is a Pythagorean triplet.

• Repeat until all possible combinations are checked.

Find node in BST with value equal to or greater than input value.

• Start at root node

• If input value is less than current node value, move to left child

• If input value is greater than or equal to current node value, move to right child

• Repeat until node with desired value is found or null is reached

Implement a phone book with search by name or phone number and prefix.

• Create an array of strings to store contacts

• Implement a function to add contacts to the array

• Implement a function to search by name or phone number

• Implement a function to search by prefix

• Use regular expressions to match prefixes

Zombie process is a terminated process that has completed execution but still has an entry in the process table. Orphan process is a process whose parent process has terminated.

• Zombie process is created when a child process completes execution but its parent process has not yet read its exit status.

• Zombie processes consume system resources and should be cleaned up by the parent process using wait() system call.

• Orphan process is a process whose parent process has terminated be...read more

WAP to find a continuous subset divisible by 7 from an array of numbers. Calculate algorithm complexity.

• Iterate through the array and calculate the prefix sum modulo 7 at each index.

• Store the prefix sum modulo 7 in a hash table with the index as the value.

• If a prefix sum modulo 7 is already in the hash table, the subarray between the two indices has a sum divisible by 7.

• Time complexity is O(n) and space complexity is O(n).

Returning kth smallest element in a BST with time complexity logn.

• Perform in-order traversal and keep track of count until kth element is reached

• If kth element is found, return it

• If kth element is not found, continue traversal

• If traversal is complete and kth element is not found, return null

• Time complexity is logn as we only traverse the height of the tree

The fastest method to sort an almost sorted array is shell sort.

• Shell sort has a time complexity of O(n log n) which is faster than bubble sort and insertion sort.

• Quick sort and merge sort have a time complexity of O(n log n) but they are not optimized for almost sorted arrays.

• Shell sort works by comparing elements that are far apart first and then gradually reducing the gap between them.

• Example: If the array is [1, 3, 2, 4, 5] and it is almost sorted, shell sort will first c...read more

Efficient solution to find k closest stars to earth from a list of stars and their distances.

• Use a priority queue to store the distances of stars from earth.

• Iterate through the list of stars and add their distances to the priority queue.

• Pop k elements from the priority queue to get the k closest stars to earth.

Given a 2D array of integers, set rows and columns to 1 if they contain 1.

• Iterate through the array to find the index of 1

• Use two arrays to keep track of rows and columns with 1

• Iterate through the rows and columns arrays to set values to 1

Find max size of a sub-string with no duplicate characters in a given string.

• Use a sliding window approach with two pointers.

• Maintain a hash set to keep track of unique characters.

• Update the maximum length of the substring as you iterate through the string.

Implement LRU cache with put, get, and remove operations.

• LRU stands for Least Recently Used.

• The cache should have a maximum capacity.

• When the cache is full, the least recently used item should be removed.

• When an item is accessed, it should be moved to the front of the cache.

• Use a doubly linked list and a hash map to implement the cache efficiently.

Algorithm to find any three numbers in an array that sum to zero.

• Sort the array in ascending order.

• Loop through the array and fix the first number.

• Use two pointers to find the other two numbers that sum to the negative of the fixed number.

• If found, return the three numbers.

• If not found, move to the next number and repeat the process.

• Time complexity: O(n^2)

Design a cab booking system for efficient and convenient service.

• Implement a user-friendly mobile app and website for booking cabs.

• Include features like real-time tracking, fare estimation, and driver ratings.

• Integrate payment options for seamless transactions.

• Develop a robust backend system to manage bookings, drivers, and customer support.

• Utilize algorithms for efficient route planning and matching drivers with passengers.

A hash table is a data structure that stores key-value pairs and uses a hash function to map keys to buckets.

• Hash function takes a key and returns an index to a bucket

• Collisions occur when multiple keys map to the same bucket

• Collision resolution techniques include chaining and open addressing

• Example: Dictionary in Python uses hash tables to store key-value pairs

Thrashing in operating systems occurs when the system is spending more time swapping data between memory and disk than actually executing tasks.

• Occurs when the system is constantly swapping data between memory and disk

• Causes a significant decrease in performance as the system is unable to effectively execute tasks

• Usually happens when the system is overloaded with too many processes or lacks sufficient memory

• Can be mitigated by optimizing memory usage or reducing the number of...read more

Retrieving min element from a max heap has a time complexity of O(log n).

• The min element is always the leftmost leaf node in the last level of the heap.

• To retrieve it, swap it with the last element in the heap and remove it.

• Then, bubble down the new root to maintain the max heap property.

• Examples: retrieving the smallest number in a priority queue implemented as a max heap.

• Examples: retrieving the smallest element in a max heap of integers.

next_permutation function generates the next greater lexicographic permutation of a sequence

• The function modifies the sequence to its next permutation if possible

• If the sequence is already the largest permutation, it rearranges it to the smallest permutation

• The function returns true if a next permutation exists, else false

• The sequence must be sorted in non-descending order before calling the function

Compute the nearest palindrome number greater than given number.

• Convert the given number to string and reverse it.

• Add the reversed string to the original number and check if it's a palindrome.

• If not, repeat the process until a palindrome is found.

• If the original number is already a palindrome, add 1 to it and repeat the process.

Check if a Binary Tree is a Binary Search Tree

• Inorder traversal of BST should be in ascending order

• Check if left child is less than parent and right child is greater than parent

• Recursively check left and right subtrees

• Use min and max values to check if nodes are within valid range

Code to check if a tree is BST or not

• Check if left subtree is BST

• Check if right subtree is BST

• Check if max value in left subtree is less than root

• Check if min value in right subtree is greater than root

Code to find sum of two numbers stored as linked list.

• Traverse both lists simultaneously and add corresponding nodes

• Keep track of carry and add it to next sum

• Create a new node for each sum and move to next node

Indexing in databases is a technique used to improve the speed of data retrieval by creating a data structure that allows for quick lookups.

• Indexes are created on columns in a database table to speed up the retrieval of rows that match a certain condition.

• Types of indexes include B-tree, hash, and bitmap indexes.

• Indexes can improve the performance of SELECT queries but may slow down INSERT, UPDATE, and DELETE operations.

• Examples of indexing include creating an index on a 'use...read more

FCFS stands for First-Come, First-Served. It is a scheduling algorithm used in operating systems.

• FCFS is a non-preemptive scheduling algorithm where the process that arrives first is executed first.

• It is a simple and easy-to-understand scheduling algorithm.

• Example: If processes P1, P2, and P3 arrive in that order, they will be executed in the same order - P1, P2, P3.

• FCFS can lead to the problem of 'convoy effect' where short processes are stuck behind long processes.

Sort a large file of numbers with limited memory

• Use external sorting algorithms like merge sort or quick sort

• Divide the file into smaller chunks that can fit into memory

• Sort each chunk and merge them together using a priority queue

• Consider using disk-based sorting techniques like replacement selection

• Optimize I/O operations to minimize disk access

Code to print elements on path from root to leaf node with max sum

• Traverse the tree and keep track of the maximum sum path

• Use recursion to traverse the tree

• Print the path when a leaf node with maximum sum is reached

Program to check if a binary tree is balanced

• Calculate height of left and right subtrees recursively

• Check if the difference in height is not more than 1

• Repeat for all nodes in the tree

• Time complexity: O(nlogn) or O(n)

• Space complexity: O(h) where h is the height of the tree

To reverse a doubly linked list, swap the next and previous pointers of each node.

• Start from the head of the list

• Swap the next and previous pointers of each node

• Update the head and tail pointers accordingly

A zombie process is a process that has completed execution but still has an entry in the process table.

• Zombie processes occur when a parent process does not properly wait for its child process to terminate.

• The zombie process remains in the process table until the parent process reads its exit status.

• Zombie processes do not consume system resources but can accumulate if not properly handled.

• They can be identified using the 'ps' command with the 'Z' status.

• Zombie processes can ...read more

Find Nth largest element in the BST

• Traverse the BST in reverse inorder and keep track of count

• If count equals N, return the current node's value

• If count exceeds N, stop traversing and return null

• If count is less than N, continue traversing

Implement a tree data structure and perform a medium to hard level operation on it.

• Create a Node class with left and right pointers

• Implement methods for insertion, deletion, and traversal

• Solve a specific problem like finding the lowest common ancestor

Hash tables have complexities related to collisions, resizing, and choosing a good hash function.

• Collisions occur when two keys map to the same index, requiring a collision resolution strategy.

• Resizing can be expensive as all elements need to be rehashed and moved to new locations.

• Choosing a good hash function is important to minimize collisions and ensure even distribution of keys.

• Examples of collision resolution strategies include chaining and open addressing.

• Hash tables ca...read more

Design an airline service for booking flights and managing reservations.

• Create a user-friendly website or mobile app for customers to search and book flights.

• Implement a secure payment system for online bookings.

• Develop a system for managing flight schedules, seat availability, and reservations.

• Include features for customers to check-in online, select seats, and view flight status.

• Offer loyalty programs and discounts for frequent flyers.