10+ Swiggy Software Developer Interview Questions and Answers

The question asks to find the total amount of rainwater that can be trapped in the given elevation map.

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

• Calculate the amount of water that can be trapped at each bar by taking the minimum of the maximum heights on both sides and subtracting the height of the bar.

• Sum up the amount of water trapped at each bar to get the total amount of rainwater trapped.

Check if a string is formed by interleaving two other strings.

• Iterate through characters of A, B, and C simultaneously to check if C is formed by interleaving A and B.

• Use dynamic programming to efficiently solve the problem.

• Handle edge cases like empty strings or unequal lengths of A, B, and C.

• Example: A = 'aab', B = 'abc', C = 'aaabbc' should return True.

The problem is to find a subarray with the maximum sum in a given array.

• Iterate through the array and keep track of the maximum sum and the current sum.

• If the current sum becomes negative, reset it to 0.

• Update the maximum sum if the current sum is greater.

• Also keep track of the start and end indices of the subarray with the maximum sum.

• Return the subarray using the start and end indices.

Given the total number of hurdles Kevin has jumped, determine how many levels he has cleared.

• Iterate through levels while subtracting hurdles from total jumped until remaining hurdles are less than current level

• Return the current level as the number of levels cleared

This question is about finding the lowest common ancestor of two nodes in a binary tree with parent references.

• Traverse from the given nodes to their respective root nodes and store the paths in two separate lists.

• Compare the two lists and find the last common node.

• Return the last common node as the lowest common ancestor.

The task is to find the next greater element for each element in an array.

• Iterate through the array from right to left.

• Use a stack to keep track of the elements that have a greater element to their right.

• For each element, pop elements from the stack until a greater element is found or the stack is empty.

• If a greater element is found, it is the next greater element for the current element.

• If the stack becomes empty, there is no greater element to the right.

• Store the next great...read more

Generate all binary strings of length 'K' with no consecutive '1's in lexicographically increasing order.

• Use backtracking to generate all possible binary strings of length 'K' with no consecutive '1's.

• Start with an empty string and recursively add '0' or '1' based on the condition of no consecutive '1's.

• Sort the generated strings in lexicographically increasing order before outputting them.

Yes, the 0/1 Knapsack problem can be solved using dynamic programming with a space complexity of not more than O(W).

• Use a 1D array to store the maximum value that can be stolen for each weight capacity from 0 to W.

• Iterate through each item and update the array based on whether including the item would increase the total value.

• The final value in the array at index W will be the maximum value that can be stolen.

The N Queens Problem involves finding all possible placements of N queens on an N x N chessboard without threatening each other.

• Use backtracking algorithm to explore all possible configurations.

• Keep track of rows, columns, and diagonals to ensure queens do not threaten each other.

• Generate valid configurations recursively and backtrack when a solution is not possible.

Calculate the number of ways Bob can complete a journey in a triangular pyramid after N steps.

• Bob can move to any adjacent vertex in a single step

• Bob must return to vertex 'O' after exactly 'N' steps

• Calculate the number of different ways Bob can complete the journey

• Return the result modulo 1000000007

• Consider the constraints provided

Detect cycles in a directed graph and return true if a cycle exists, false otherwise.

• Use Depth First Search (DFS) to detect cycles in the directed graph.

• Maintain a visited array to keep track of visited vertices and a recursion stack to detect back edges.

• If a vertex is visited and is present in the recursion stack, then a cycle exists.

• Example: For the input 4 4, the graph has a cycle 0 -> 1 -> 2 -> 3 -> 1.

Find the intersection point of two lines on a 2D plane given their coordinates.

• Calculate the slopes of both lines using the given coordinates.

• Use the slope-intercept form of a line to find the equations of the two lines.

• Solve the equations simultaneously to find the intersection point.

• Return the coordinates of the intersection point with precision up to 6 decimal places.

Find the second largest element in an array of integers.

• Iterate through the array to find the largest and second largest elements.

• Handle cases where all elements are identical.

• Return -1 if a second largest element does not exist.

The task is to compute the number of structurally unique BSTs that can be formed using an exact number of unique values.

• Use dynamic programming to solve the problem efficiently.

• The number of structurally unique BSTs can be calculated using Catalan numbers.

• For N nodes, the number of structurally unique BSTs is given by the Nth Catalan number.

• Example: For N=3, the number of structurally unique BSTs is 5.

Generate all possible subsequences of a given string.

• Use recursion to generate all possible subsequences by including or excluding each character in the string.

• Maintain a current index to keep track of the characters being considered.

• Append the current character to each subsequence generated so far.

• Recursively call the function with the next index to include or exclude the next character.

• Base case: When the current index reaches the length of the string, add the generated sub...read more

Design a scalable system for Twitter with key components and architecture.

• Use microservices architecture for scalability and fault isolation.

• Key components include user service, tweet service, timeline service, and notification service.

• Use a distributed database like Cassandra for storing tweets and user data.

• Implement a message queue like Kafka for handling real-time updates and notifications.

• Use a caching layer like Redis for improving performance.

• Consider using a CDN for s...read more