Software Developer

This can be solved both: recursively and iteratively.
The recursive approach is more intuitive. First reverse all the nodes after head. Then we need to set head to be the final node in the reversed list. We simply set its next node in the original list (head -> next) to point to it and sets its next to NULL. The recursive approach has a O(N) time complexity and auxiliary space complexity.
For solving the question is constant auxiliary space, iterative approach can be used. We maintain 3 pointers, current, next and previous, abbreviated as cur, n and prev respectively. All the events occur in a chain.
1. Assign prev=NULL, cur=head .
2. Next, repeat the below steps until no node is left to reverse:
2.1) Initialize n to be the node after cur. i.e. (n=cur->next)
2.2) Then make cur->next point to prev (next node pointer).
2.3) Then make prev now point to the cur node.
2.4)  At last move cur also one node ahead to n.
The prev pointer will be the last non null node and hence the answer.

The recursive approach is to traverse the tree in a depth-first manner. The moment you encounter either of the nodes node1 or node2, return the node. The least common ancestor would then be the node for which both the subtree recursions return a non-NULL node. It can also be the node which itself is one of node1 or node2 and for which one of the subtree recursions returns that particular node.

Pseudo code :
 

LowestCommonAncestor(root, node1, node2) 
{
	if(not root)
		return NULL
	if (root == node1 or root == node2) 
		return root
	left = LowestCommonAncestor(root.left, node1, node2)
	right = LowestCommonAncestor(root.right, node1, node2)
	if(not left)
		return right
	else if(not right)
		return left
	else
		return root
}

Internal fragmentation happens when the memory is split into mounted-sized blocks. Whenever a method is requested for the memory, the mounted-sized block is allotted to the method. just in case the memory allotted to the method is somewhat larger than the memory requested, then the distinction between allotted and requested memory is that the internal fragmentation.

The uninitialized data segment is also known as a . bss segment that stores all the uninitialized global, local and external variables. If the global, static and external variables are not initialized, they are assigned with zero value by default.

The Simple Approach is to find the floor of the square root, try with all-natural numbers starting from 1. Continue incrementing the number until the square of that number is greater than the given number.
Algorithm: 
1. Create a variable (counter) i and take care of some base cases, i.e when the given number is 0 or 1.
2. Run a loop until i*i <= n , where n is the given number. Increment i by 1.
3. The floor of the square root of the number is i – 1
Time Complexity: O(√ n). 
The Better Approach would be to use Binary Search. The idea is to find the largest integer i whose square is less than or equal to the given number. The values of i * i is monotonically increasing, so the problem can be solved using binary search. 

Algorithm: 
1. Take care of some base cases, i.e when the given number is 0 or 1.
2. Create some variables, lowerbound l = 0, upperbound r = n, where n is the given number, mid and ans to store the answer.
3. Run a loop until l <= r , the search space vanishes
4. Check if the square of mid (mid = (l + r)/2 ) is less than or equal to n, If yes then search for a larger value in second half of search space, i.e l = mid + 1, update ans = mid
5. Else if the square of mid is more than n then search for a smaller value in first half of search space, i.e r = mid – 1
6. Print the value of answer.
Time Complexity : O(logn)

given path of file: /root/home/ooo/abc.c how does an os finds where abc.c

The system locates the root directory of the file system. A pointer to this is kept in memory since the partition is mounted. The pointer to this top-level inode includes pointers to the data blocks of the top-level directory.
The system reads the dents (directory entries) there searching for the one for “root”. Once the dent is found, it also includes an inode pointer to the directory.
Using the inode for “root”, it finds the data blocks for that directory.
The system reads the dents in the “root” directory, searching for the one for “home”, and picking up the inode pointer for the “home” directory.
Using the inode for “home”, it finds the data blocks for that directory.
The system reads the dents in the “home” directory, searching for the one for “ooo”, and picking up the inode pointer for the “ooo” directory.
Using the inode for “ooo”, it finds the data blocks for that directory.
The system reads the dents in the “ooo” directory, searching for the one for “abc.c”, and picking up the inode pointer for the “abc.c” file.
At this point, the open(“/root/home/ooo/abc.c”,”r”) syscall completes.
When the program does a read() syscall, the system uses the inode for “abc.c”, and finds the data blocks for that file.
Data blocks are transferred to the program. read() completes.

In UNIX systems it looks something like this:

When you compile a program with gcc, it wraps a startup routine around your main() function. This routine calls your main() function and saves its return value. It then calls the exit() function (which your program might call as well), that does some general clean up. This function then again calls _exit(), which is a system call that tells the OS to save the returned value of your main() function in the process table (where meta information about your process is saved). As soon as another process calls wait() on your process id (PID), your returned value is given to the calling process and your process is removed from the table.

Segmentation fault is a specific kind of error caused by accessing memory that “does not belong to you.” 
When a piece of code tries to do read and write operation in a read only location in memory or freed block of memory, it is known as core dump. It is an error indicating memory corruption.

Tip 1 : The cross questioning can go intense some time, think before you speak.

Tip 2 : Be open minded and answer whatever you are thinking, in these rounds I feel it is important to have opinion.

Tip 3 : Context of questions can be switched, pay attention to the details. It is okay to ask questions in these round, like what are the projects currently the company is investing, which team you are mentoring. How all is the work environment etc.