System Engineer

Approach : 

1) Get the middle node and split the list into two halves. We can use a two-pointer technique to get the middle node by running a slow and a fast pointer.

2) The idea here is to move both the slow and fast pointer simultaneously until fast reaches the end of the list.

3) Here, for every single step slow takes, fast will make a jump twice of the slow pointer.

4) When the fast pointer reaches the end of the list, the slow pointer will reach the middle of the list.

5) Now you can split into two two lists, by taking slow's next or slow as the head of second list.

6) Make sure to make the tail of first list null.

7) We can now ask the sort function to sort the left and right halves of the list.

8) We can assume the lists are now sorted, we now can use the merge two sorted list technique to merge the lists to eventually make the final sorted list and return the new head pointing to the list.

TC : O(N * logN), where N = number of nodes in the linked list
SC : O(log(N))

Approach (Using Kadane's Algo) :

1) Declare a variable ‘maxSum’ and initialize it with ‘minimum integer’

2) Declare a variable ‘localSum’ and initialize it with ‘0’

3) Declare 3 counter variables as ‘start’ , ‘end’ , ‘newStart’ as 0, 0, 0

4) Run a loop from i = 0 to N
4.1) Add a current element to ‘localSum’

4.2) If 'localSum' is greater than 'maxSum'
Update ‘maxSum’ with 'localSum', update start with ‘newStart’ and end with loop counter ‘i’

4.3) If 'localSum' is equal to ‘maxSum’ and the difference between ‘end’ and ‘start’ is less than the
difference between ‘newStart’ and ‘i’
Update start with ‘newStart’ and end with ‘i’

4.4) If 'localSum' is below ‘0’
Update ‘localSum’ as 0 and set ‘newStart' as ‘i’ + 1

5) Return the part of the array starting from ‘start’ and ending at ‘end’


TC : O(N), where N=size of the array
SC : O(N), we need a final array to store the result maximum subarray.

Approach : This was a very standard questions related to DFS and I had already practiced it on platforms like LeetCode and CodeStudio therefore I coded the solution preety fast at the interview.

Algorithm : 

1) We have a function ‘numberOfIsland’ in which we are iterating over the whole grid.

2) We will initialise ‘islands’ to 0 to count the number of islands. Whenever we encounter a 1(land), we will call ‘dfs’ and increment ‘islands’ by 1. 

3) The ‘dfs’ function works as follows:
3.1) If indices are out of bound or the value present at the current cell is 0, then simply return 0.

3.2) Else, Mark the cell as 0, so that we don’t count cells in an island more than once and call the ‘dfs’ function in 8-directions.


TC : O(N * M), where N and M are the number of rows and columns in the matrix respectively.
SC : O(N*M)

C++ is an Object-oriented programming language and it supports Polymorphism as well :

1) Compile Time Polymorphism: C++ supports compile-time polymorphism with the help of features like templates, function overloading, and default arguments.

2) Runtime Polymorphism: C++ supports Runtime polymorphism with the help of features like virtual functions. Virtual functions take the shape of the functions based on the type of object in reference and are resolved at runtime.

There are three types of constructors:

1) Default Constructor – With no parameters.

2) Parametric Constructor – With Parameters. Create a new instance of a class and also passing arguments simultaneously.

3) Copy Constructor – Which creates a new object as a copy of an existing object.

1) The main disadvantage of using inheritance is two classes get tightly coupled. That means one cannot be used independently of the other. If a method or aggregate is deleted in the Super Class, we have to refactor using that method in SubClass.

2) Inherited functions work slower compared to normal functions.

3) Need careful implementation otherwise leads to improper solutions.

The DROP TABLE statement is used to drop an existing table in a database.

Syntax : DROP TABLE table_name;

A trigger is a task that executes in response to some predefined database event, such as after a new row is added to a particular table. Specifically, this event involves inserting, modifying, or deleting table data, and the task can occur either prior to or immediately following any such event. 
Triggers have many purposes, including:

1) Audit Trails
2) Validation
3) Referential integrity enforcement

Normalization is a process of reducing redundancy by organizing the data into multiple tables. Normalization leads to better usage of disk spaces and makes it easier to maintain the integrity of the database. 

Denormalization is the reverse process of normalization as it combines the tables which have been normalized into a single table so that data retrieval becomes faster. JOIN operation allows us to create a denormalized form of the data by reversing the normalization.

Tip 1 : Be Confident 
Tip 2 : Prepare your resume throughout
Tip 3 : Projects play so important role in your candidature