50+ HashedIn by Deloitte Software Developer Interview Questions and Answers

Find the maximum number of chocolates that can be collected by two friends moving in a grid.

• Start from the top-left and top-right corners, move diagonally down to collect chocolates

• Calculate the total chocolates collected by each friend and sum them up for the final result

• Consider all possible paths for both friends to maximize the total chocolates collected

Given an encrypted string with repeated substrings represented by counts, find the K'th character of the decrypted string.

• Parse the encrypted string to extract substrings and their counts

• Iterate through the substrings and counts to build the decrypted string

• Track the position in the decrypted string to find the K'th character

Reverse a singly linked list of integers in O(N) time and O(1) space complexity.

• Iterate through the linked list, reversing 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 list.

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

• Example: Given 1 -> 2 -> 3 -> 4 -> NULL, reverse it to get 4 -> 3 -> 2 -> 1 -> NULL with ...read more

Identify all the leaders in a sequence of numbers, where a leader is greater than all elements to its right.

• Iterate through the sequence from right to left, keeping track of the maximum element encountered so far.

• If an element is greater than the maximum element encountered so far, it is a leader.

• Add the leaders to a result sequence while maintaining the original order.

• The rightmost element is always a leader.

Count the number of trailing zeros in the factorial of a given number.

• Trailing zeros are created by pairs of 2 and 5 in the factorial.

• Count the number of 5s in the prime factorization of N to find the trailing zeros.

• For example, for N=10, there are 2 trailing zeros as there are two 5s in the prime factorization of 10.

Find the sum of the subarray with the maximum sum among all subarrays in a given array.

• Iterate through the array and keep track of the maximum sum subarray seen so far.

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

• Update the maximum sum subarray if the current sum is greater than the previous maximum sum.

Given an array of unique integers with two missing numbers, find and return the missing numbers.

• Iterate through the array and mark the presence of each number in a separate boolean array.

• Iterate through the boolean array to find the missing numbers.

• Return the missing numbers in increasing order.

Convert a given integer number into its corresponding word representation.

• Implement a function that converts the given number into words by breaking it down into its individual digits and mapping them to their word representation.

• Handle special cases like numbers less than 20, multiples of 10, and numbers in the hundreds and thousands place.

• Ensure that there is a space between every two consecutive words and all characters are in English lowercase letters.

Convert a binary tree into its mirror tree by interchanging left and right children of non-leaf nodes.

• Traverse the binary tree in a recursive manner.

• Swap the left and right children of each non-leaf node.

• Continue this process until all nodes are visited.

• Example: Input binary tree: 1 2 3 4 -1 5 6 -1 7 -1 -1 -1 -1 -1 -1, Output mirror tree: 1 3 2 6 5 4 -1 -1 -1 -1 -1 7 -1 -1 -1

Santa needs to find the quickest path to deliver gifts in Ninja town by jumping over buildings with least travel time.

• Santa starts at (0, 0) and needs to deliver gifts to (N-1, M-1) on Christmas Eve.

• Santa can jump to (x+1, y+1), (x+1, y), or (x, y+1) from any cell (x, y) within grid boundaries.

• Travel time between two buildings equals the absolute difference in their heights.

• Find the quickest path with least travel time using dynamic programming or Dijkstra's algorithm.

Given an array of integers and a target, find all pairs of elements that add up to the target.

• Iterate through the array and for each element, check if the target - element exists in a hash set.

• If it exists, add the pair to the result. If not, add the element to the hash set.

• Handle cases where the same element is used twice to form a pair.

• Return (-1, -1) if no pair is found.

Find two lines to form a container with maximum water holding capacity.

• Use two pointers approach to find the maximum area by calculating the area between the lines and moving the pointers based on the height of the lines.

• Keep track of the maximum area found so far.

• The area is calculated as the minimum of the two line heights multiplied by the distance between the lines.

• Example: For input A = [1,8,6,2,5,4,8,3,7], the maximum area is 49 between lines at indices 1 and 8.

Group anagrams in an array of strings based on character frequency.

• Iterate through each string in the input array

• For each string, sort the characters and use the sorted string as a key in a hashmap to group anagrams

• Return the grouped anagrams as output

The task is to determine if there exist four distinct numbers in an array that sum up to a given target value.

• Iterate through all possible combinations of four distinct numbers in the array.

• Use a nested loop to check all combinations efficiently.

• Keep track of the sum of each combination and compare it with the target value.

• Return 'Yes' if a valid combination is found, otherwise return 'No'.

Detect and remove loop in a singly linked list in place with O(n) time complexity and O(1) space complexity.

• Use Floyd's Tortoise and Hare algorithm to detect the loop in the linked list.

• Once the loop is detected, find the start of the loop using the same algorithm.

• Adjust the pointers to remove the loop and return the modified linked list.

• Example: For input 5 2 and elements 1 2 3 4 5, output should be 1 2 3 4 5.

Find the lowest common ancestor of two nodes in a Binary Search Tree.

• Traverse the BST from the root to find the LCA of the given nodes.

• Compare the values of the nodes with the values of P and Q to determine the LCA.

• Handle cases where one node is the ancestor of the other or when one of the nodes is the root.

• Use recursion to efficiently find the LCA in the BST.

• Consider edge cases such as when the nodes are not present in the BST.

Merge K sorted arrays into a single sorted array.

• Create a min-heap to store the first element of each array along with the array index.

• Pop the smallest element from the heap and add it to the result array.

• If the array from which the element was popped has more elements, add the next element to the heap.

• Repeat until all elements are merged into a single sorted array.

Sort an array of 0s, 1s, and 2s in linear time complexity.

• Use three pointers to keep track of 0s, 1s, and 2s while iterating through the array.

• Swap elements based on the values encountered to sort the array in-place.

• Time complexity should be O(N) and space complexity should be O(1).

Determine the minimum number of platforms needed at a railway station based on arrival and departure times of trains.

• Sort the arrival and departure times in ascending order.

• Use two pointers to keep track of overlapping schedules.

• Increment the platform count when a new train arrives before the previous one departs.

• Return the maximum platform count needed.

The Lowest Common Ancestor (LCA) problem involves finding the lowest node in a tree that is an ancestor of two given nodes.

• LCA is the lowest node in a tree that is an ancestor of both given nodes.

• The tree is rooted at node 1 for each test case.

• Paths from each node to the root are considered to find the LCA.

• Constraints include the number of test cases, nodes, queries, and node values.

• Time limit for the solution is 1 second.

Find the weight of the last stone remaining after smashing stones together.

• Sort the stones in descending order.

• Simulate the smashing process by repeatedly smashing the two heaviest stones until only one stone is left.

• Return the weight of the last stone, or 0 if no stone is left.

The task is to find all distinct triplets in an array that sum up to a specified number.

• Iterate through all possible triplets using three nested loops.

• Check if the sum of the triplet equals the target sum.

• Print the triplet if found, else print -1.

Detect if a singly linked list forms a cycle by checking if a node's next points back to a previous node.

• Use Floyd's Tortoise and Hare algorithm to detect a cycle in the linked list.

• Maintain two pointers, slow and fast, where slow moves one step at a time and fast moves two steps at a time.

• If there is a cycle, the fast pointer will eventually meet the slow pointer.

• If the fast pointer reaches the end of the list (null), there is no cycle.

• Time complexity: O(N), Space complexity...read more

Check if two strings are anagrams of each other by comparing their sorted characters.

• Sort the characters of both strings and compare them.

• Use a dictionary to count the frequency of characters in each string and compare the dictionaries.

• Ensure both strings have the same length before proceeding with the comparison.

• Example: For input 'str1 = "spar", str2 = "rasp"', the output should be True.

Find the length of the longest mountain subarray in an array of integers.

• Identify peaks in the array where the elements transition from ascending to descending order.

• Calculate the length of the mountain subarray starting from each peak.

• Track the length of the longest mountain subarray found so far.

• Consider edge cases like when there are no mountains in the array.

Remove duplicates from a string of lowercase English letters.

• Use a set to keep track of unique characters seen so far.

• Iterate through the string and add each character to the set if it hasn't been seen before.

• Construct a new string by appending characters that are not in the set.

Determine if a given string is a palindrome considering only alphanumeric characters.

• Remove non-alphanumeric characters from the input string.

• Compare characters from start and end of the string to check for palindrome.

• Handle edge cases like empty string or single character input.

Find the length of the longest strictly increasing subsequence in an array of integers.

• Use dynamic programming to solve this problem efficiently.

• Initialize an array to store the length of the longest increasing subsequence ending at each index.

• Iterate through the array and update the length of the longest increasing subsequence for each element.

• Return the maximum value in the array as the result.

Yes, I was given a schema and asked to write SQL queries based on it.

• I was given a schema for a database that included tables, columns, and relationships between them.

• I had to write SQL queries to retrieve specific data from the database based on the schema provided.

• For example, I was asked to write a query to retrieve all customers who made a purchase in the last month.

• I had to understand the schema to correctly write the queries and ensure they returned the desired results.

Designing a social media platform with friend requests and posts.

• Implement user profiles with friend request functionality.

• Allow users to create and share posts on their profiles.

• Include news feed to display posts from friends.

• Implement notifications for friend requests and post interactions.

• Include privacy settings for posts and friend requests.

• Consider implementing features like comments, likes, and shares for posts.

Code to find max length subarray matching the given sum

• Use a sliding window approach to iterate through the array

• Keep track of the current sum and the maximum length subarray

• If the current sum exceeds the given sum, move the window's left pointer

• If the current sum matches the given sum, update the maximum length subarray

• Return the maximum length subarray

A banking system is a software application that allows customers to perform financial transactions, manage accounts, and access banking services.

• The system should have user authentication and authorization mechanisms to ensure security.

• It should support various types of accounts such as savings, checking, and loans.

• The system should allow customers to deposit, withdraw, transfer funds, and view transaction history.

• It should have features like bill payment, account statements,...read more

Design a music player similar to Spotify.

• Implement user authentication for personalized playlists and recommendations

• Create a user-friendly interface with features like search, shuffle, repeat, and create playlists

• Integrate a recommendation system based on user listening history and preferences

SQL query to retrieve output from given tables

• Identify the tables and their relationships

• Determine the columns to be selected

• Use appropriate join and filter conditions

• Group and aggregate data if required

Designing APIs and finding second largest value in SQL query.

• For API design, consider RESTful principles and use clear and concise naming conventions.

• For finding second largest value in SQL, use ORDER BY and LIMIT clauses.

• Consider edge cases such as duplicates and null values.

• Test thoroughly to ensure correct functionality.

CLI snake and ladders game code

• Create a board with 100 cells using a 10x10 array

• Define snakes and ladders positions as an array of tuples

• Use a loop to alternate player turns and move them based on dice roll

• Check for snakes and ladders and update player position accordingly

• Print the board after each turn and declare winner when a player reaches cell 100

Sort an array of 0s, 1s, 2s in linear time.

• Use three pointers to keep track of the positions of 0s, 1s, and 2s.

• Traverse the array once and swap elements based on their values.

• The final array will have 0s, 1s, and 2s grouped together in that order.

Check if there exists a pair of numbers in the array that add up to a given sum.

• Iterate through the array and for each element, check if the difference between the sum and the element exists in the array using a hash table.

• Alternatively, sort the array and use two pointers to traverse from both ends towards the middle, adjusting the pointers based on the sum of the current pair.

I want to join Hashedin because of its reputation for innovative projects and collaborative work environment.

• Reputation for innovative projects

• Collaborative work environment

• Opportunities for growth and learning

Method overloading is having multiple methods with the same name but different parameters. Method overriding is having a subclass method with the same name and parameters as a superclass method.

• Method overloading is used to provide different ways of calling the same method with different parameters.

• Method overriding is used to provide a specific implementation of a method in a subclass that is already defined in a superclass.

• Method overloading is resolved at compile-time base...read more

Finding the Kth smallest element in an array.

• Sort the array and return the Kth element.

• Use a min heap to find the Kth smallest element.

• Use quickselect algorithm to find the Kth smallest element.

• Divide and conquer approach using binary search.

• Use selection algorithm to find the Kth smallest element.

Rotate an array of strings k times

• Create a temporary array to store elements that will be rotated

• Use modulo operator to handle cases where k is greater than array length

• Update the original array with elements from the temporary array

Abstraction is the concept of hiding complex implementation details and showing only the necessary information. Encapsulation is bundling data and methods that operate on the data into a single unit.

• Abstraction focuses on what an object does rather than how it does it

• Encapsulation restricts access to some of an object's components, protecting the object's integrity

• Abstraction allows for creating simple interfaces for complex systems

• Encapsulation helps in achieving data hiding...read more

Use a hash table to find two numbers in a linked list that add up to a target sum.

• Traverse the linked list and store each node's value in a hash table along with its index.

• For each node, check if the difference between the target sum and the current node's value exists in the hash table.

• If it does, return the indices of the two nodes.

• Example: Given linked list 2 -> 4 -> 3 -> 5 and target sum 7, return indices 1 and 2.

Database design for Instagram platform

• Create tables for users, posts, comments, likes, followers, and hashtags

• Use primary and foreign keys to establish relationships between tables

• Include fields such as user_id, post_id, comment_id, like_id, follower_id, and hashtag_id

• Implement indexes for faster data retrieval

• Consider scalability and performance optimization techniques

Multiple inheritance is a feature in object-oriented programming where a class can inherit attributes and methods from more than one parent class.

• Allows a class to inherit attributes and methods from multiple parent classes

• Can lead to the Diamond Problem where ambiguity arises if two parent classes have a method with the same name

• Languages like C++ support multiple inheritance

Transpose a matrix by swapping rows with columns

• Iterate through each row and column and swap the elements

• Create a new matrix with swapped rows and columns

• Ensure the new matrix has the correct dimensions

Implement a swap method for two variables.

• Create a temporary variable to store the value of one variable.

• Assign the value of the second variable to the first variable.

• Assign the value of the temporary variable to the second variable.

The depth of a binary tree is the number of edges on the longest path from the root node to a leaf node.

• Depth of a binary tree can be calculated recursively by finding the maximum depth of the left and right subtrees and adding 1.

• The depth of a binary tree with only one node (the root) is 0.

• Example: For a binary tree with root node A, left child B, and right child C, the depth would be 1.