RaRa Delivery Sde1 Interview Questions, Process, and Tips

Queue can be implemented using a singly linked list where insertion happens at the tail and deletion at the head.

• Create a Node class with data and next pointer

• Create a Queue class with head and tail pointers

• Enqueue operation: create a new node and add it to the tail of the list

• Dequeue operation: remove the node at the head of the list and update the head pointer

• Peek operation: return the data at the head of the list wi

To fill a BST with a sorted array, we can use a recursive approach.

• Find the middle element of the array and make it the root of the BST

• Recursively construct the left subtree using the left half of the array

• Recursively construct the right subtree using the right half of the array

Fibonacci number generation using recursion

• Define a function that takes an integer as input

• If the input is 0 or 1, return the input

• Else, return the sum of the function called with input-1 and input-2

• Call the function with the desired input

The fastest sorting algorithm is QuickSort.

• QuickSort has an average time complexity of O(n log n).

• It is a divide and conquer algorithm that recursively partitions the array.

• It is widely used in practice and has many variations such as randomized QuickSort.

• Other fast sorting algorithms include MergeSort and HeapSort.

Clone a linked list with a random pointer.

• Create a new node for each node in the original list

• Store the mapping of original node to new node in a hash table

• Set the random pointer of each new node based on the mapping

• Traverse the original list and the new list simultaneously to set the next pointers

Printing Fibonacci numbers using recursion only

• Define a recursive function that takes two arguments, n and a list to store the Fibonacci sequence

• Base case: if n is 0 or 1, return the list

• Recursive case: append the sum of the last two elements in the list to the list and call the function with n-1

• Call the function with n and an empty list to start the sequence

• Print the list of Fibonacci numbers

Reflection in Java allows inspection and modification of runtime behavior of a program.

• Reflection is achieved through classes in the java.lang.reflect package.

• It allows access to class information, constructors, methods, and fields at runtime.

• Reflection can be used to create new objects, invoke methods, and access or modify fields.

• Example: Class c = Class.forName("java.lang.String");

• Example: Method m = c.getDeclared

Given an array of integers and a target sum, find a pair of integers that add up to the target sum.

• Create a hash table to store the difference between the target sum and each element in the array

• Iterate through the array and check if the current element is present in the hash table

• If it is, return the current element and its corresponding hash table value as the pair that adds up to the target sum

• If no such pair is fou

Binary search in a rotated array can be done by finding the pivot point and then applying binary search on the two subarrays.

• Find the pivot point by comparing mid element with the first and last elements of the array

• Apply binary search on the two subarrays formed by the pivot point

• Repeat until the element is found or the subarray is empty

• Time complexity is O(log n)

• Example: [4,5,6,7,0,1,2], target=0. Pivot point is 3. B

Negative elements in array won't affect binary search. Time complexity remains O(log n).

• Binary search works by dividing the array into two halves and comparing the middle element with the target element.

• If the middle element is greater than the target, search in the left half, else search in the right half.

• Negative elements won't affect this process as long as the array is sorted.

• Time complexity remains O(log n) as the

Array rotation is the process of shifting the elements of an array to the left or right.

• To rotate an array to the left, move the first element to the end of the array and shift the remaining elements to the left.

• To rotate an array to the right, move the last element to the beginning of the array and shift the remaining elements to the right.

• The number of rotations can be specified by the user.

• Example: If the array is [...read more

Polymorphism is the ability of an object to take on many forms. It allows objects of different classes to be treated as if they were of the same class.

• Polymorphism is achieved through method overriding and method overloading.

• Method overriding is when a subclass provides its own implementation of a method that is already provided by its parent class.

• Method overloading is when a class has two or more methods with the sam...read more

Overloading is having multiple methods with the same name but different parameters. Overriding is having a method in the subclass with the same name and parameters as in the superclass.

• Overloading is compile-time polymorphism while overriding is runtime polymorphism.

• Overloading is used to provide different ways of calling the same method while overriding is used to provide a specific implementation of a method in the s...read more