10+ Josh Technology Group Software Developer Interview Questions and Answers for Freshers

The task is to determine if the given binary tree nodes form exactly one valid binary tree.

• Check if there is only one root node (a node with no parent)

• Check if each node has at most one parent

• Check if there are no cycles in the tree

• Check if all nodes are connected and form a single tree

The maximum number of balanced binary trees possible with a given height is to be counted and printed.

• A balanced binary tree is one in which the difference between the left and right subtree heights is less than or equal to 1.

• The number of balanced binary trees can be calculated using dynamic programming.

• The number of balanced binary trees with height 'H' can be obtained by summing the product of the number of balanced binary trees for each possible left and right subtree hei...read more

The task is to sort an array in a wave form, where each element is greater than or equal to its adjacent elements.

• Iterate through the array and swap adjacent elements if they do not follow the wave pattern

• Start from the second element and compare it with the previous element, swap if necessary

• Continue this process until the end of the array

• Repeat the process for the remaining elements

• Return the sorted wave array

The task is to check if there exist two unique elements in the given BST such that their sum is equal to the given target 'K'.

• Traverse the BST in-order and store the elements in a sorted array

• Use two pointers, one at the beginning and one at the end of the array

• Check if the sum of the elements at the two pointers is equal to the target 'K'

• If the sum is less than 'K', move the left pointer to the right

• If the sum is greater than 'K', move the right pointer to the left

• Repeat the...read more

The task is to find the maximum sum of node values of any subtree that is a Binary Search Tree(BST).

• Traverse the binary tree in a bottom-up manner

• For each node, check if it forms a BST and calculate the sum of its subtree

• Keep track of the maximum sum encountered so far

• Return the maximum sum

The task is to find all nodes in a binary tree that are at a distance K from a given node.

• Implement a function that takes the binary tree, target node, and distance K as input.

• Use a depth-first search (DFS) algorithm to traverse the tree and find the nodes at distance K.

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

• When the distance equals K, add the current node to the result list.

• Continue the DFS traversal to explore other nodes in the...read more

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

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

• Iterate through each item and update the array based on whether including the item would increase the total value.

• The final value in the array at index W will be the maximum value that can be stolen.

Yes, the problem can be solved in less than O(N*log(N)) time complexity using the Quick Select algorithm.

• Implement Quick Select algorithm to find the Kth largest element in O(N) time complexity.

• Partition the array around a pivot element and recursively search in the left or right partition based on the position of the pivot.

• Once you find the Kth largest element, return all elements greater than or equal to it in non-decreasing order.

Find the size of the largest BST subtree in a binary tree.

• Traverse the tree in a bottom-up manner to check if each subtree is a BST.

• Keep track of the size of the largest BST found so far.

• Recursively check if the current subtree is a BST and update the size accordingly.

The problem involves finding the length of the longest common subsequence between two given strings.

• Use dynamic programming to solve the problem efficiently.

• Create a 2D array to store the lengths of common subsequences of substrings.

• Iterate through the strings to fill the array and find the length of the longest common subsequence.

• Example: For input STR1 = 'abcde' and STR2 = 'ace', the longest common subsequence is 'ace' with a length of 3.

Find the minimum number of multiplication operations required to multiply a series of matrices together.

• Use dynamic programming to solve this problem efficiently.

• Create a 2D array to store the minimum number of operations needed to multiply matrices.

• Iterate through different combinations of matrices to find the optimal solution.

• Consider the dimensions of the matrices to determine the number of operations required.

• Calculate the minimum number of operations by considering all p...read more

Given a string, find the longest palindromic substring within it.

• Iterate through the string and expand around each character to find palindromes

• Keep track of the longest palindrome found so far

• Return the longest palindromic substring