UI/UX Engineer 2

Step 1: The approach is to first traverse the tree. To see the maximum value in the given path, the pre-order traversal is used to traverse the given binary tree. 
Step 2: While traversing the tree, keep track of the maximum value of the node that we have seen so far. If the current node is greater or equal to the max value, then increment the count of the visible node and update the max value with the current node value.

function solution(T) {
if (!T) {
return 0;
}
let leftSubTreeVisibleNodes = getVisibleNodes(T.l, T.x);
let rightSubTreeVisibleNodes = getVisibleNodes(T.r, T.x);
return leftSubTreeVisibleNodes + rightSubTreeVisibleNodes + 1;
}

function getVisibleNodes(tree, prevMax) {
if (!tree) {
return 0;
}
// pass max value up to current node to check for visibility
let leftCount = getVisibleNodes(tree.l, Math.max(prevMax, tree.x));
let rightCount = getVisibleNodes(tree.r, Math.max(prevMax, tree.x));
if (tree.x >= prevMax) {
return leftCount + rightCount + 1;
} else {
return leftCount + rightCount;
}
}

Tip 1: Focus on JS concepts and o/p questions.
Tip 2: Cross-check your solution thoroughly before discussing it with the interviewer.
Tip 3: Study theory as well as keep examples ready.

Step 1: Traverse the linked list using two-pointers. 
Step 2: Move one pointer by one and the other pointers by two. When the fast pointer reaches the end, the slow pointer will reach the middle of the linked list.

Step 1: Calculate the sizes of the given two linked lists. 
Step 2: If sizes are the same, then calculate the sum using recursion. Hold all nodes in the recursion call stack till the rightmost node, calculate the sum of the rightmost nodes and forward carry to the left side. 
Step 3: If the size is not the same, then follow the below steps: 
a) Calculate the difference in sizes of two linked lists. Let the difference be diff 
b) Move different nodes ahead in the bigger linked list. Now use step 2 to calculate the sum of the smaller list and right sub-list (of the same size) of a larger list. Also, store the carry of this sum. 
c) Calculate the sum of the carry (calculated in the previous step) with the remaining left sub-list of a larger list. Nodes of this sum are added at the beginning of the sum list obtained in the previous step.

We can use an interface for multiple similar classes having similar functionality. It helps us to define a contract and also we can assign instances of any class to that interface type item at runtime.

Tip 1: Study the concept of promises and its advantage over callbacks.
Tip 2: Study promise APIs like all, any etc.

Step 1: Level order traversal is used. 
Step 2: Print the rightmost node of every level. So, do a level order traversal on the tree and print the last node at every level.

function deepCopy(obj) {
const copyObj = {}
for (const key in obj) {
if (typeof obj[key] === 'object') {
copyObj[key] = deepCopy(obj[key]);
} else {
copyObj[key] = obj[key];
}
}
return copyObj
}

Prepare for some behavioural questions as well.