30+ Josh Technology Group Software Developer Intern Interview Questions and Answers

Multiply two numbers represented as linked lists and return the resultant multiplied linked list.

• Create a function that takes two linked lists as input and returns the product as a linked list

• Traverse both linked lists to extract the numbers, multiply them, and create a new linked list for the product

• Handle carry over while multiplying digits and adding to the result linked list

Add two numbers represented by linked lists and return the head of the sum list.

• Traverse both linked lists simultaneously while keeping track of carry from previous sum

• Create a new linked list to store the sum of the two numbers

• Handle cases where one linked list is longer than the other by padding with zeros

• Update the sum and carry values accordingly while iterating through the linked lists

Print a two-dimensional matrix in spiral order.

• Iterate through the matrix in a spiral order by keeping track of the boundaries.

• Print elements in the order: top row, right column, bottom row, left column.

• Repeat the process for inner submatrices until all elements are printed.

Rearrange the nodes of a singly linked list in a specific order without altering the data of the nodes.

• Use two pointers to split the linked list into two halves, reverse the second half, and then merge the two halves alternately.

• Ensure to handle cases where the number of nodes is odd or even separately.

• Keep track of the head and tail of each half to properly rearrange the nodes.

• Ensure to update the next pointers of the nodes correctly to rearrange the linked list in the desir...read more

Reverse a linked list in groups of size K

• Iterate through the linked list in groups of size K

• Reverse each group of nodes

• Handle cases where the last group has fewer nodes than K

Merge two binary trees by summing overlapping nodes and retaining non-null nodes.

• Traverse both trees simultaneously in preorder fashion

• If both nodes are not null, sum their values for the new node

• If one node is null, use the non-null node as the new node

• Recursively merge the left and right subtrees

Maximize vaccines administered on a specific day while following certain rules.

• Distribute vaccines evenly over the given number of days.

• Ensure the difference in vaccines administered between consecutive days is at most 1.

• Maximize the number of vaccines administered on the specified day.

• Keep track of the total number of vaccines administered to not exceed the maximum limit.

• Implement a function to calculate the maximum number of vaccines administered on the specified day.

Rearrange array elements in a zig-zag manner where every odd index element is greater than its neighbors.

• Iterate through the array and swap elements at odd indices to satisfy the zig-zag condition.

• Ensure that the swapped elements are greater than their neighbors.

• Multiple correct zig-zag rearrangements may exist for a given array.

Yes, the 0/1 Knapsack problem can be solved using a space complexity of not more than O(W) using dynamic programming.

• Use a 1D array to store the maximum value that can be stolen for each weight from 0 to W.

• Iterate through the items and update the array based on the current item's weight and value.

• The final value in the array will be the maximum value that can be stolen within the weight capacity of the knapsack.

Find nodes at distance K from a given node in a binary tree.

• Perform a depth-first search starting from the target node to find nodes at distance K.

• Use a recursive function to traverse the tree and keep track of the distance from the target node.

• Maintain a set to store visited nodes and avoid revisiting them.

• Return the list of nodes found at distance K from the target node.

• Example: If the target node is 5 and K is 2, the output should be [7, 4, 0, 8].

Matching nuts and bolts based on size in a one-to-one mapping strategy.

• Iterate through the nuts and bolts arrays to find matching pairs based on size.

• Use sorting algorithms like quicksort to efficiently match nuts and bolts.

• Ensure the implementation modifies the input arrays directly to reflect the proper matched order.

The task is to maximize the total sweetness of the part that Ninja will get by dividing chocolates into K + 1 parts.

• Iterate through the array of sweetness values to find the maximum sweetness value.

• Use binary search to find the maximum sweetness that Ninja can obtain by making cuts.

• Consider the constraints while implementing the solution.

• Handle multiple test cases efficiently.

Dijkstra's algorithm is used to find the shortest path distance from a source node to all vertices in an undirected graph.

• Implement Dijkstra's algorithm to calculate shortest path distances

• Use a priority queue to efficiently select the next node to visit

• Initialize distances to all nodes as infinity, except for the source node as 0

• Update distances based on the weights of edges and choose the shortest path

• Handle disconnected nodes by assigning a maximum positive integer value

Calculate the total sum of all possible root-to-leaf paths in a binary tree.

• Traverse the tree from root to leaf nodes, keeping track of the current path sum.

• Add the path sum to the total sum when reaching a leaf node.

• Use recursion to explore all possible paths in the tree.

• Return the total sum modulo (10^9 + 7) as the final result.

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 reverse the list

• Use three pointers to keep track of current, previous, and next nodes

• Update the head of the reversed linked list once the reversal is complete

Flatten a binary tree into a linked list following pre-order traversal order.

• Use the binary tree's right pointer as the linked list's 'next' pointer.

• Set each node's left pointer to NULL.

• Implement the solution without printing within the function.

• Follow pre-order traversal to flatten the binary tree into a linked list.

The diameter of a binary tree is the longest path between any two end nodes in the tree.

• Traverse the tree to find the longest path between two leaf nodes.

• Use depth-first search (DFS) to calculate the height of each subtree.

• The diameter of the tree is the maximum of the sum of heights of left and right subtrees + 1.

Dijkstra's algorithm is used to find the shortest path from a source node to all other nodes in a graph with weighted edges.

• Implement Dijkstra's algorithm to find the shortest path distances from the source node to all other nodes.

• Use a priority queue to efficiently select the next node with the shortest distance.

• Initialize distances to all nodes as infinity except for the source node which is 0.

• Update distances to neighboring nodes if a shorter path is found.

• Repeat the proce...read more

The problem involves printing the spiral order of a given matrix of integers.

• Iterate through the matrix in a spiral order by keeping track of the boundaries.

• Print the elements in the order: top row, right column, bottom row, left column.

• Continue this process until all elements are printed in spiral order.

Identify equilibrium indices in a given sequence by finding positions where sum of elements before and after is equal.

• Iterate through the sequence and calculate prefix sum and suffix sum at each index

• Compare prefix sum and suffix sum to find equilibrium indices

• Handle edge cases where no equilibrium index exists

• Return the indices as a sequence of integers or an empty sequence

Reverse a linked list in groups of size K.

• Iterate through the linked list in groups of size K.

• Reverse each group of nodes.

• Handle cases where the number of elements in the last group is less than K.

Find all nodes at a specified distance K from a given node in a binary tree.

• Traverse the binary tree to find the target node.

• Use depth-first search to explore nodes at distance K from the target node.

• Keep track of the distance from the target node while traversing.

• Return a list of node values at distance K from the target node.

• Handle cases where no nodes are found at the specified distance.

Convert a binary search tree into a Greater Tree by updating each node's data to the sum of its original data plus the data of all nodes with greater or equal values.

• Traverse the BST in reverse inorder (right, root, left) to update nodes with the sum of greater nodes.

• Keep track of the sum of greater nodes encountered so far while traversing.

• Update each node's data with the sum of greater nodes and continue traversal.

Return the level order traversal of a binary tree given in level order.

• Use a queue to perform level order traversal of the binary tree

• Start by pushing the root node into the queue

• While the queue is not empty, dequeue a node, print its value, and enqueue its children