40+ Rupicard Interview Questions and Answers

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 to keep track of the current, previous, and next nodes while reversing the linked list.

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

Find the minimum time required to rot all fresh oranges in a grid.

• Use Breadth First Search (BFS) to simulate the rotting process of oranges.

• Track the time taken to rot all fresh oranges and return the result.

• If any fresh oranges remain after simulation, return -1 as it is impossible to rot all oranges.

Find the maximum sum of any contiguous subarray within an array of integers.

• Iterate through the array and keep track of the maximum sum of subarrays encountered so far.

• At each index, decide whether to include the current element in the subarray or start a new subarray.

• The maximum subarray sum can be calculated using Kadane's algorithm.

• Example: For array [34, -50, 42, 14, -5, 86], the maximum sum is 137.

• Example: For array [-5, -1, -8, -9], the maximum sum is -1.

Implement a function to delete a node at a specified position in a linked list.

• Traverse the linked list to find the node at the specified position.

• Update the pointers to skip the node to be deleted.

• Handle edge cases like deleting the head or tail node.

• Return the modified linked list.

To delete a node in a singly linked list given a reference to the node.

• Traverse the linked list to find the node to be deleted.

• Update the value of the node to be deleted with the value of the next node.

• Point the next pointer of the node to be deleted to the next node's next pointer.

The task is to find the smallest positive integer value that cannot be represented as a sum of elements of any proper subset of the given array.

• The array is sorted in non-decreasing order, so we can iterate through the array and keep track of the maximum sum we can form.

• If the current element is greater than the maximum sum + 1, then the maximum sum + 1 is the smallest positive integer that cannot be represented.

• If all elements in the array can be represented as a sum of subs...read more

This question asks to find the minimum number of platforms required at a railway station so that no train needs to wait.

• Sort the arrival and departure times arrays in ascending order.

• Initialize a variable 'platforms' to 1 and 'maxPlatforms' to 1.

• Iterate through the arrival and departure times arrays simultaneously.

• If the current arrival time is less than or equal to the current departure time, increment 'platforms'.

• If 'platforms' is greater than 'maxPlatforms', update 'maxPla...read more

Sort an array of 0s, 1s, and 2s in increasing order.

• Use a three-pointer approach to sort the array in a single pass.

• Initialize low, mid, and high pointers at the start, iterate through the array, and swap elements accordingly.

• Example: If the current element is 0, swap it with the element at the low pointer and increment both low and mid pointers.

Print nodes of a binary tree in spiral order traversal.

• Use a queue to perform level order traversal.

• Alternate between printing nodes from left to right and right to left at each level.

• Handle null nodes appropriately.

• Example: For input '1 2 3 -1 -1 4 5 -1 -1 -1 -1', output should be '1 3 2 4 5'.

Create a deep copy of a linked list with random pointers.

• Iterate through the original linked list and create a new node for each node in the list.

• Store the mapping of original nodes to their corresponding new nodes in a hashmap.

• Iterate through the list again to set the next and random pointers of the new nodes based on the mapping.

• Return the head of the newly created deep copied linked list.

Delete the middle node of a singly linked list in O(N) time complexity and O(1) space complexity.

• Identify the middle node using slow and fast pointers technique.

• Update the pointers to skip the middle node.

• Handle edge cases like no middle node or two middle nodes.

• Perform the deletion in a single traversal of the linked list.

• Return the modified linked list after deletion.

Identify and return the bottom right view of a given binary tree by viewing it from an angle of 45 degrees from the bottom right side.

• Traverse the binary tree in a right-to-left manner and keep track of the last node encountered at each level.

• Use a queue for level order traversal and update the result array with the last node at each level.

• Return the result array sorted in ascending order as the bottom right view of the binary tree.

Given a list of integers, find the next greater element for each element in the list.

• Iterate through the list from right to left and use a stack to keep track of elements.

• Pop elements from the stack until a greater element is found or the stack is empty.

• Store the next greater element for each element in a result array.

• If no greater element is found, store -1 in the result array.

The task is to find the length of the longest common subsequence between two given strings.

• Implement a function to find the longest common subsequence between two strings.

• Use dynamic programming to solve this problem efficiently.

• Iterate through the strings and build a matrix to store the lengths of common subsequences.

• The value in the bottom-right corner of the matrix will be the length of the longest common subsequence.

Group anagrams together in a list of strings.

• Iterate through the list of strings and sort each string to group anagrams together.

• Use a hashmap to store the sorted string as key and the original string as value.

• Return the values of the hashmap as the grouped anagrams.

Maximize profit by scheduling jobs within their deadlines.

• Sort the jobs array in descending order of profits.

• Iterate through the sorted array and schedule jobs based on deadlines.

• Keep track of completed jobs and their profits to calculate the total profit.

• Return the maximum profit achieved by scheduling jobs within deadlines.

The task is to determine the lexicographically smallest array that can be obtained by performing at most 'K' swaps of consecutive elements.

• Sort the array in non-decreasing order and keep track of the number of swaps made.

• Iterate through the array and swap adjacent elements if it results in a lexicographically smaller array.

• Continue swapping until the maximum number of swaps 'K' is reached or the array is lexicographically smallest.

• Return the final lexicographically smallest a...read more

Find the largest element in a sorted array smaller than or equal to a given integer X.

• Use binary search to efficiently find the floor value of X in the sorted array.

• Compare the middle element of the array with X and adjust the search accordingly.

• Return the element before or equal to X as the floor value, or -1 if no such element exists.

Function to swap '3' and '4' without using if-else

• Use XOR operator to swap the values

• Convert the input to ASCII code and perform the swap

• Use a lookup table to map the values

Finding an element in a sorted 2D matrix

• Start from the top right corner or bottom left corner

• Compare the target element with the current element

• Move left or down if the target is smaller, else move right or up

• Repeat until the target is found or all elements are checked

Find the odd repeating element from an array of strings

• Use a hash table to count the frequency of each element

• Iterate through the hash table to find the element with an odd count

Design a dictionary using trie with insert, update and delete operations.

• Implement a Trie data structure with nodes containing a character and a boolean flag to indicate end of word

• For insert operation, traverse the trie and add nodes for each character in the word

• For update operation, delete the existing word and insert the updated word

• For delete operation, mark the end of word flag as false and delete the node if it has no children

• Use recursion for traversal and deletion

• Exa...read more

Print all the connected components in a given graph.

• Traverse the graph using DFS or BFS algorithm.

• Maintain a visited array to keep track of visited nodes.

• For each unvisited node, perform DFS or BFS and add all visited nodes to a connected component.

• Repeat until all nodes are visited.

• Print all connected components.

SQL query to find Nth highest salary from table

• Use ORDER BY and LIMIT clauses

• Use subquery to get the Nth highest salary

• Handle cases where there are less than N distinct salaries

Fill the glass to the brim, then pour out exactly half.

• Fill the glass completely with water

• Pour the water into another container until the glass is half full

• Pour the remaining water back into the glass

A program to find the minimum length of a string containing a given substring.

• Use a sliding window approach to iterate through the string and check for the substring.

• Keep track of the minimum length of the string containing the substring.

• Return the minimum length found.

Program to create a spiral array using 2D-array

• Create a 2D-array with given dimensions

• Initialize variables for row, column, and direction

• Fill the array in a spiral pattern by changing direction when necessary

• Return the spiral array

Sharding is a database partitioning technique to improve performance and scalability by distributing data across multiple servers.

• Sharding involves breaking up a database into smaller, more manageable parts called shards.

• Each shard contains a subset of the data, allowing for parallel processing and improved performance.

• Sharding helps distribute the workload across multiple servers, preventing bottlenecks and improving scalability.

• Examples of sharding implementations include M...read more

Types of DS and a real life scenario

• Arrays - storing a list of names

• Linked Lists - managing a playlist

• Stacks - undo/redo functionality in text editors

• Queues - managing customer requests in a call center

• Trees - organizing files in a computer

• Graphs - social network connections

OOPs in Python refers to Object-Oriented Programming concepts like classes, objects, inheritance, encapsulation, and polymorphism.

• Classes: Blueprint for creating objects with attributes and methods.

• Objects: Instances of classes that contain data and behavior.

• Inheritance: Ability to create a new class based on an existing class.

• Encapsulation: Restricting access to certain components of an object.

• Polymorphism: Ability to use a single interface for different data types.

Multithreading is the ability of a CPU to execute multiple threads concurrently.

• Allows for parallel execution of tasks

• Improves performance by utilizing multiple CPU cores

• Requires synchronization to prevent race conditions

• Example: Running a web server that can handle multiple client requests simultaneously