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:
1. Initialize n to be the node after cur. i.e(n=cur->next)
2. Then make cur->next point to prev (next node pointer).
3. Then make prev now point to the cur node.
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 basic idea is, keep a hash map which stores the characters in string as keys and their positions as values, and keep two pointers which define the max substring. move the right pointer to scan through the string , and meanwhile update the hash map. If the character is already in the hash map, then move the left pointer to the right of the same character last found. Note that the two pointers can only move forward. 
The time and space complexity for this solution will be O(n).

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
}

The solution can be built using the concept of counting sort.
1. Maintain the count of the frequency of each digit in the number. 
2. If the number is non-negative :
2. 1 Place the smallest digit (except 0) at the left most of the required number and decrement the frequency of that digit by 1.
2 .2 Place all remaining digits in ascending order from left to right.
3. Else if it is a negative number then:
3.1 Place the largest digit at the left most of the required number. and decrement the frequency of that digit by 1.
3.2 Place all remaining digits in descending order from right to left.

Tip 1 : Be sure to do your homework on the organization and its culture before the interview.
Tip 2 : Employers want to understand how you use your time and energy to stay productive and efficient. Be sure to emphasize that you adhere to deadlines and take them seriously.
Tip 3 : Interviewers like to hear stories about candidates. Make sure your story has a great beginning, a riveting middle, and an end that makes the interviewer root for you to win the job. Talk about a relevant incident that made you keen on the profession you are pursuing and follow up by discussing your education.