SDE - 1

1. CHAR datatype is used to store character string of fixed length. VARCHAR datatype is used to store character string of variable length
2. In CHAR, If the length of string is less than set or fixed length then it is padded with extra memory space. In VARCHAR, If the length of string is less than set or fixed length then it will store as it is without padded with extra memory spaces.
3. CHAR stands for “Character”. VARCHAR stands for “Variable Character”
4. Storage size of CHAR datatypes is equal to n bytes i.e. set length. Storage size of VARCHAR datatype is equal to the actual length of the entered string in bytes.
5. We should use CHAR datatype when we expect the data values in a column are of same length. We should use VARCHAR datatype when we expect the data values in a column are of variable length.

Traverse linked list using two pointers. 
Move one pointer by one and the other pointers by two. 
When the fast pointer reaches the end slow pointer will reach the middle of the linked list.

1. In normalization, Non-redundancy and consistency data are stored in set schema. In denormalization, data are combined to execute the query quickly.
2. In normalization, Data redundancy and inconsistency is reduced. In denormalization, redundancy is added for quick execution of queries.
3. Data integrity is maintained in normalization. Data integrity is not maintained in denormalization.
4. In normalization, redundancy is reduced or eliminated. In denormalization redundancy is added instead of reduction or elimination of redundancy.

To solve the question using a max heap, make a max heap of all the elements of the list. Run a loop for k-1 times and remove the top element of the heap. After running the loop, the element at top will be the kth largest element, return that. Time Complexity : O(n + klogn)
The question can also be solved using a min heap. 
Approach:
1. Create a min heap class with a capacity of k
2. When the heap reaches capacity eject the minimum number. 
3. Loop over the array and add each number to the heap. 
4. At the end, the largest k number of elements will be left in the heap, the smallest of them being at the top of the heap, which is the kth largest number
The time complexity for this solution is O(N logK).

For numbers up-to 4 digits, the idea is to create arrays that store individual parts of output strings. One array is used for single digits, one for numbers from 10 to 19, one for 20, 30, 40, 50,.. etc, and one for powers of 10. 
Next, keep dividing the number into different parts and append the corresponding word in the output string.

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; }

Polymorphism is defined as the ability to take more than one form. It is a feature that provides a function or an operator with more than one definition. It can be implemented using function overloading, operator overload, function overriding, virtual function.
Polymorphism is of two types :
1. Compile Time Polymorphism : 
Invokes the overloaded functions by matching the number and type of arguments. The information is present during compile-time. This means the C++ compiler will select the right function at compile time. It is achieved through function overloading and operator overloading.
2. Run Time Polymorphism : 
This happens when an object’s method is called during runtime rather than during compile time. Runtime polymorphism is achieved through function overriding. The function to be called is established during runtime.

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 : Talk about a relevant incident that made you keen on the profession you are pursuing and follow up by discussing your education.