Software Engineer

Floyd's algorithm can be used to solve this question.
Define two pointers slow and fast. Both point to the head node, fast is twice as fast as slow. There will be no cycle if it reaches the end. Otherwise, it will eventually catch up to the slow pointer somewhere in the cycle.

Let X be the distance from the first node to the node where the cycle begins, and let X+Y be the distance the slow pointer travels. To catch up, the fast pointer must travel 2X + 2Y. L is the cycle size. The total distance that the fast pointer has travelled over the slow pointer at the meeting point is what we call the full cycle.
X+Y+L = 2X+2Y
L=X+Y
Based on our calculation, slow pointer had already traveled one full cycle when it met fast pointer, and since it had originally travelled A before the cycle began, it had to travel A to reach the cycle's beginning! 
After the two pointers meet, fast pointer can be made to point to head. And both slow and fast pointers are moved till they meet at a node. The node at which both the pointers meet is the beginning of the loop.
 

Pseudocode :
 

detectCycle(Node *head) 
{
	Node *slow=head,*fast=head;

	while(slow!=NULL && fast!=NULL && fast->next!=NULL) 
	{
		slow = slow->next; 
		fast = fast->next->next; 
		if(slow==fast) 
		{
			fast = head;
			while(slow!=fast) 
			{
				slow = slow->next;
				fast=fast->next;
			}
			return slow;
		}
	}

	return NULL; 
}

Intuition :
Lets K be the total nodes in the linked list.
Observation : The Nth node from the end is (K-N+1)th node from the beginning.
So the problem simplifies down to that we have to find (K-N+1)th node from the beginning.

One way of doing it is to find the length (K) of the linked list in one pass and then in the second pass move (K-N+1) step from the beginning to reach the Nth node from the end.
To do it in one pass. Let’s take the first pointer and move N step from the beginning. Now the first pointer is (K-N+1) steps away from the last node, which is the same number of steps the second pointer require to move from the beginning to reach the Nth node from the end.

Approach : 
Take two pointers; the first will point to the head of the linked list and the second will point to the Nth node from the beginning.
Now keep incrementing both the pointers by one at the same time until the second is pointing to the last node of the linked list.
After the operations from the previous step, the first pointer should point to the Nth node from the end now. So, delete the node the first pointer is pointing to.

There are four types of Java access modifiers:

Private: The access level of a private modifier is only within the class. It cannot be accessed from outside the class.
Default: The access level of a default modifier is only within the package. It cannot be accessed from outside the package. If you do not specify any access level, it will be the default.
Protected: The access level of a protected modifier is within the package and outside the package through child class. If you do not make the child class, it cannot be accessed from outside the package.
Public: The access level of a public modifier is everywhere. It can be accessed from within the class, outside the class, within the package and outside the package.

In Java, all objects are dynamically allocated on Heap. This is different from C++ where objects can be allocated memory either on Stack or on Heap. In C++, when we allocate the object using new(), the object is allocated on Heap, otherwise on Stack if not global or static.
In Java, when we only declare a variable of a class type, only a reference is created (memory is not allocated for the object). To allocate memory to an object, we must use new(). So the object is always allocated memory on heap.

Algorithm:

QUICKSORT (array A, start, end) 
{ 
	if (start < end) 
	{ 
		p = partition(A, start, end) 
		QUICKSORT (A, start, p - 1) 
		QUICKSORT (A, p + 1, end) 
	} 
} 

Partition Algorithm :

The partition algorithm rearranges the sub-arrays in a place.

PARTITION (array A, start, end) 
{ 
	pivot = A[end] 
	i = start-1 
	for j = start to end -1 
	{ 
		do if (A[j] < pivot) 
		{ 
			then i = i + 1 
			swap A[i] with A[j] 
		}
	} 
	swap A[i+1] with A[end] 
	return i+1 
}

MERGE_SORT(arr, beg, end) 

if beg < end 
	set mid = (beg + end)/2 
MERGE_SORT(arr, beg, mid) 
MERGE_SORT(arr, mid + 1, end) 
MERGE (arr, beg, mid, end) 
end of if 

END MERGE_SORT

1. Serial port(COM Port):
A serial port is also called a communication port and they are used for connection of external devices like a modem, mouse, or keyboard (basically in older PCs). Serial cables are cheaper to make in comparison to parallel cables and they are easier to shield from interference. There are two versions of it, which are 9 pin model and 25 pin model. It transmits data at 115 KB/sec. 

2. Parallel Port (LPT ports):
Parallel ports are generally used for connecting scanners and printers. It can send several bits at the same time as it uses parallel communication. Its data transfer speed is much higher in comparison with the serial port. It is a 25 pin model. It is also known as Printer Port or Line Printer Port.