SDE - 1

A simple approach would be to create a new arrays with size as sum of the sizes of both the arrays. Copy the elements of both the arrays in the new array and sort the array. 

A space optimized approach also exists. While traversing the two sorted arrays parallelly, if we encounter the jth second array element is smaller than ith first array element, then jth element is to be included and replace some kth element in the first array. 

Algorithm
1) Initialize i,j,k as 0,0,n-1 where n is size of arr1 
2) Iterate through every element of arr1 and arr2 using two pointers i and j respectively
if arr1[i] is less than arr2[j]
increment i
else
swap the arr2[j] and arr1[k]
increment j and decrement k

3) Sort both arr1 and arr2

The brute force solution is to access nodes level by level and check if the current level is odd, then store nodes of this level in an array. Reverse the array and store elements back in the tree.

Another approach could be using a stack.
Traverse the tree in a depth-first fashion and for each level : 
• If the level is odd, push the left and right child (if exists) in a stack.
• If the level is even, replace the value of the current node with the top of the stack.

Pseudocode:
reverseAlternate(Node root)
{

declare a queue q of node type
push the root node in q
define a node temp

initialise level as 1

declare a stack of int type 

while (q is not empty) {
initialise a variable n to the current size of q
while (n != zero) {

fetch the front element of queue and assign it to variable temp

if (level % 2) {
if (left child of temp exists) {
push left child of temp in queue q
push key of left child in stack s
}

if (right child of temp exists) {
push right child of temp in queue q
push right of left child in stack s
}
}

else {

Replace the value of node (key of temp) with top of the stack

if (left child of temp exists) {
push left child of temp in queue q
}

if (right child of temp exists) {
push right child of temp in queue q
}
}
}

level++;
}
}

Remote data/file sharing: It allows a file to be transparently accessed by processes of any node of the system irrespective of the file’s location. Example: Any process ‘A’ can create the file and share it with other processes ‘B’ or ‘C’ and the same file can be accessed/modified process running in other nodes.
User mobility: Users in the distributed systems are allowed to work in any system at any time. So, users need not relocate secondary storage devices in distributed file systems.
Availability: Distributed file systems keep multiple copies of the same file in multiple places. Hence, the availability of the distributed file system is high and it maintains a better fault tolerance for the system. 
Diskless workstations: Distributed file systems allow the use of diskless workstations to reduce noise and heat in the system. Also, diskless workstations are more economical than disk full workstations.

Tip 1: Design your structure and functions according to the requirements and try to convey your thoughts properly to the interviewer so that you do not mess up while implementing the idea .

The ConcurrentHashMap class of the Java collections framework provides a thread-safe map. That is, multiple threads can access the map at once without affecting the consistency of entries in a map.
It implements the ConcurrentMap interface.

To access the App history tab, you first need to launch the Task Manager. We found it easiest to use the keyboard shortcut "Ctrl + Shift + Esc." If you did not access this tool on Windows 10 before, it opens in the so-called compact view, providing a list of apps currently running on your device. Clicking or tapping More details opens the full version of the Task Manager.
Click or tap More details to open the full version of the Task Manager
By default, the full version of the Task Manager opens in the Processes tab. The next step is to go to the App history tab.