10+ Delhivery Software Developer Interview Questions and Answers

Perform BFS traversal on an undirected and disconnected graph starting from vertex 0.

• Implement BFS traversal algorithm starting from vertex 0

• Use a queue to keep track of visited nodes and their neighbors

• Print the traversal order in sorted order for each node's connected nodes

BFS traversal of an undirected and disconnected graph starting from vertex 0.

• Implement BFS algorithm to traverse the graph starting from vertex 0.

• Use a queue to keep track of visited nodes and their neighbors.

• Ensure to visit all connected components of the graph.

• Print the BFS traversal sequence for each test case in a separate line.

• Handle cases where not all vertices are reachable from vertex 0.

Find the smallest positive integer that cannot be expressed as the sum of elements from any proper subset of a non-decreasing sorted array of positive numbers.

• Start with the smallest possible sum that can be represented, which is 1.

• Iterate through the array and update the smallest sum that cannot be represented.

• Return the final smallest sum that cannot be represented.

Diameter of a binary tree is the longest path between any two leaf nodes.

• Calculate the height of left and right subtrees recursively.

• Calculate the diameter recursively using the formula max(left_height + right_height + 1, max(left_diameter, right_diameter)).

• Return the maximum diameter.

To find interchanged terms from an AP series

• Identify the common difference between terms

• Swap the positions of adjacent terms

• Check if the new series is also an AP

• Repeat until no more interchanged terms can be found

Design an LRU cache to store least recently used items efficiently.

• Use a combination of a doubly linked list and a hashmap to store and retrieve items in O(1) time complexity.

• When an item is accessed, move it to the front of the linked list to mark it as the most recently used.

• If the cache is full, remove the least recently used item from the end of the linked list and the hashmap.

Design a stack that supports getmin in O(1) time and O(1) space complexities.

• Use two stacks, one for storing the actual values and the other for storing the minimum values.

• When pushing a new value, check if it is smaller than the current minimum value and push it to the minimum stack if it is.

• When popping a value, check if it is the current minimum value and pop it from the minimum stack if it is.

• To get the minimum value, simply return the top value of the minimum stack.

Patch is used to update a specific part of a resource, while put is used to replace the entire resource.

• Patch is used for partial updates, while put is used for full updates.

• Patch is idempotent, meaning multiple identical patch requests will have the same effect as a single request, while put is not necessarily idempotent.

• Example: Using patch to update the title of a blog post without affecting other fields, while using put to replace the entire blog post with a new one.

Database indexing is a technique to improve the performance of database queries.

• Indexing creates a data structure that allows for faster retrieval of data.

• Indexes are created on one or more columns of a table.

• Queries that use indexed columns can be executed faster.

• Indexes can be clustered or non-clustered.

• Clustered indexes determine the physical order of data in a table.

• Non-clustered indexes create a separate structure to store the indexed data.

• Examples of indexing include B-...read more

OOPs concepts are the fundamental principles of object-oriented programming.

• Encapsulation - binding data and functions together in a single unit

• Inheritance - creating new classes from existing ones

• Polymorphism - ability of objects to take on many forms

• Abstraction - hiding implementation details from the user

• Examples: class, object, inheritance, encapsulation, polymorphism, abstraction

LRU cache is a data structure that stores the most recently used items and discards the least recently used items.

• LRU stands for Least Recently Used

• It has a fixed size and when the cache is full, the least recently used item is removed to make space for a new item

• It uses a combination of a doubly linked list and a hash map to achieve O(1) time complexity for both insertion and deletion

• Example: A web browser cache that stores the most recently visited web pages for faster acce...read more