MTS 1

Union :
1) Initialize an empty hash set or hash map mp.
2) Iterate through the first array and put every element of the first array in the set mp.
3) Repeat the process for the second array.
4) Print the set mp.

Intersection :
1) Initialize an empty set mp.
2) Iterate through the first array and put every element of the first array in the set mp.
3) For every element x of the second array, do the following :
Search x in the set mp. If x is present, then print it.

Time complexity : O(m+n) under the assumption that hash table search and insert operations take O(1) time.
Space complexity : O(m+n) in case of Union and O(min(m,n)) in case of Intersection

Inorder traversal requires that we print the leftmost node first and the right most node at the end. 
So basically for each node we need to go as far as down and left as possible and then we need to come back and go right. So the steps would be : 
1. Start with the root node. 
2. Push the node in the stack and visit it's left child.
3. Repeat step 2 while node is not NULL, if it's NULL then pop the topmost node from the stack and print it.
4. Now move to node's right child and repeat step 1
5. Repeat the above steps while node is not NULL and stack is not empty.

1. In static loading, the complete program is linked and complied without dependency of an external program. In dynamic loading, all the modules are loaded dynamically. The developer provides a reference to all of them and the rest of the work is done at execution time.

2. In static loading, absolute data and program are loaded into the memory to start execution. In dynamic loading, loading of data and information takes bit by bit in run time.
 

3. In static loading, the linker combines the object program with other object modules to make a a single program. In dynamic loading, the linking process takes place dynamically in relocatable form. Data is loaded into the memory only when it is needed in the program.
 

4. In static loading, the processing speed is faster as no files are updated during the processing time. In dynamic loading, the processing speed is slower as files are uploaded at the time of processing.
 

5. In static loading, the code may or may not be executed once it is loaded into the memory. In dynamic loading,, execution takes place only when it is required.

C Code − This is the code that you have written. This code is sent to the Preprocessors section.

Preprocessing − In this section the preprocessor files are attached with our code. We have use different header files like stdio.h, math.h etc. These files are attached with the C Source code and the final C Source generates. (‘#include’, ‘#define’ These are Preprocessor Directives.)

Compiler − After generating the preprocessed source code, it moves to the compiler and the compiler generates the assembly level code after compiling the whole program.

Assembler − This part takes the assembly level language from compiler and generates the Object code, this code is quite similar to the machine code (set of binary digits).

Linker − Linker is another important part of the compilation process. It takes the object code and link it with other library files, these library files are not the part of our code, but it helps to execute the total program. After linking the Linker generates the final Machine code which is ready to execute.

Loader − A program, will not be executed until it is not loaded in to Primary memory. Loader helps to load the machine code to RAM and helps to execute it. While executing the program is named as Process. So process is (Program in execution).

Banker’s Algorithm is used to resource allocation and deadlock avoidance that determine to safety by simulating the allocation for predetermined maximum possible amounts of all resources, then makes an “s-state” check to test for possible activities, before deciding whether allocation should be allowed to continue.
Banker’s Algorithm is named because it is implemented in the banking sector, and main objective of using this algorithm is to check that loan can be sanctioned or not to clients.

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.

Initialization : 
malloc() allocates a memory block of given size (in bytes) and returns a pointer to the beginning of the block. malloc() doesn’t initialize the allocated memory. If you try to read from the allocated memory without first initializing it, then you will invoke undefined behavior, which will usually mean the values you read will be garbage.

calloc() allocates the memory and also initializes every byte in the allocated memory to 0. If you try to read the value of the allocated memory without initializing it, you’ll get 0 as it has already been initialized to 0 by calloc().

Parameters : 
malloc() takes a single argument, which is the number of bytes to allocate.

Unlike malloc(), calloc() takes two arguments: 
1) Number of blocks to be allocated. 
2) Size of each block in bytes.

Return Value : 
After successful allocation in malloc() and calloc(), a pointer to the block of memory is returned otherwise NULL is returned which indicates failure.

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.