Etraveli Group Interview Questions and Answers for Freshers

Quick sort is a divide and conquer algorithm that sorts the array by selecting a pivot element and partitioning the other elements around it. Merge sort is also a divide and conquer algorithm that divides the array into two halves, sorts them separately and then merges them.

• Quick sort has an average time complexity of O(n log n) while merge sort has a time complexity of O(n log n) in all cases.

• Quick sort is an in-place...read more

System design for Naukri.com platform

• Identify user requirements and design the system architecture accordingly

• Use scalable and reliable technologies for high traffic handling

• Implement features like job search, job posting, resume upload, etc.

• Ensure data security and privacy of users

• Integrate with third-party services like payment gateways, social media platforms, etc.

Highest sum of contiguous subarray in an array

• Use Kadane's algorithm to find the maximum sum subarray

• Initialize max_so_far and max_ending_here to 0

• Loop through the array and update max_ending_here and max_so_far

• Return max_so_far as the highest subset sum subarray

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

• Traverse both linked lists and add the corresponding nodes.

• Handle carry over while adding nodes.

• Create a new linked list to store the sum and return it.

Quick sort is faster but unstable, while merge sort is slower but stable.

• Quick sort uses a pivot element to divide the array into two parts and recursively sorts them.

• Merge sort divides the array into two halves, sorts them separately, and then merges them.

• Quick sort has an average time complexity of O(n log n), while merge sort has a time complexity of O(n log n) in all cases.

• Quick sort is not stable, meaning that the...read more

Reverse a given Linked List with O(1) and O(N) space complexity.

• For O(1) space complexity, use three pointers to reverse the links in place.

• For O(N) space complexity, use a stack to store the nodes and then pop them to create the reversed list.

• Be careful with edge cases such as empty list or list with only one node.

Find the celebrity in a party of N people where only one person is known to everyone.

• The celebrity doesn't know anyone in the party.

• We can use a stack to keep track of potential celebrities.

• If a person knows someone, they cannot be a celebrity.

• If a person doesn't know someone, we can push them onto the stack.

• After iterating through all people, we check if the stack has only one person and if that person is known to eve

Merge Sort and Quick Sort are sorting algorithms that use divide and conquer approach.

• Merge Sort divides the array into two halves, sorts them recursively, and then merges them.

• Quick Sort selects a pivot element, partitions the array around the pivot, and recursively sorts the sub-arrays.

• Merge Sort has a worst-case time complexity of O(nlogn), while Quick Sort has an average case time complexity of O(nlogn).

• Merge Sort ...read more

Compute amount of water trapped in an elevation map after raining

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

• Calculate the amount of water that can be trapped on each bar using the difference between the minimum of the two maximum heights and the height of the bar

• Add up the amount of water trapped on each bar to get the total amount of water trapped

Zigzag traversal of a binary tree is a way of traversing the tree in a zigzag pattern.

• Use a stack to keep track of nodes to be visited.

• For each level, alternate between adding nodes to the stack from left to right and right to left.

• Pop nodes from the stack and add their children to the stack in the appropriate order.

• Repeat until all nodes have been visited.

Sort a dictionary by key or value in ascending/descending order.

• Use sorted() function with lambda function to sort by key or value.

• For ascending order, use reverse=False and for descending order, use reverse=True.

• Example: sorted_dict = sorted(dictionary.items(), key=lambda x: x[0], reverse=True)