Associate Software Engineer

Approach : 

1) Sort both strings, so that all the same characters come together.

2) Then loop through both strings together and check each element in both strings one by one.

3) If at any position, the characters are found to be different or if the lengths of the two strings are different, they cannot be anagrams.

4) Otherwise, they will be anagrams.


TC : O(N * log(N) + (M * log(M))), where N and M are the lengths of the two input strings.
SC : O(1)

Approach : 

1) Declare an array ‘DP’ of size N+1.

2) Set DP[N] as 0.

3) Set DP[N-1] as abs(HEIGHTS[N-1] - HEIGHTS[N-2]).

4) For i in range N-2 to 1:
4.1) Set ONE_JUMP as DP[i+1] + abs(HEIGHTS[i-1]-HEIGHTS[i]).
4.2) Set TWO_JUMP as DP[i+2] + abs(HEIGHTS[i-1]-HEIGHTS[i+1]).
4.3) Set DP[i] as the minimum of ONE_JUMP and TWO_JUMP.

5) Set ‘ANS’ as DP[1].

6) Return ANS.


TC : O(N), where N = number of stairs
SC : O(N)

Approach (Using Recursion) : 

1) Defining the preorder(node, ans) : 
i) If the node is an empty node, we will return from the function.
ii) Insert node value into the ans array.
ii) Now we will traverse to the left subtree.
iv) Create a recursive call preorder(left child of the node, ans).
v) Now we will traverse to the right subtree.
vi) Create a recursive call preorder(right child of the node, ans).

2) We will define an array ans to store the preorder traversal of the given tree.

3) We will call preorder(root, ans).

4) Return the array ans.


//Pseudo Code

vectorans;

void preorder(TreeNode*root)
{
if(root)
{
ans.push_back(root->val);
preorder(root->left);
preorder(root->right);
}
}


TC : O(N), where N = number of nodes in the tree.
SC : O(N)

Approach (Using Bit Masking) :

1) We have two possibilities either selecting a number in subset or not.

2) A bit can be either 0 or 1, thus we can use this to denote whether the corresponding element belongs to the current subset or not. So each bit pattern will represent a subset. So we will get all the subsets.

3) Let’s say we have a given array ARR.

4) Let ANS = [ [] ] is our answer.

5) Iterate 0<= I <=2^N and do:
5.1) CURR = []

5.2) Iterate over ARR[i] for each 0 <= J < N and do:
If the Jth bit is set in I then include the Jth element to CURR.

5.3) Append CURR to ANS.


//Pseudo Code : 

vector>PowerSet(vectorarr)
{
int n=arr.size();
int total=(1<>ans;
for(int i=0; itmp;
for(int j=0; j {
if(i&(1< tmp.push_back(arr[j]); 
}
ans.push_back(tmp);
}
return ans;
}


TC : O(N*(2^N)), where N = length of the string.
SC : O(N*(2^N))

Approach :

1) Calculate the length of both the lists, say len1 and len2

2) Get the absolute difference of the lengths, diff = |len1 – len2|

3) Now traverse the long list from the first node till ‘diff’ nodes so that from there onwards both the lists have equal
number of nodes

4) Then traverse both the lists in parallel and check whether a common node is reached (Note that getting a common
node is done by comparing the address of the nodes, not the data)
4.1) If yes, return that node’s data
4.2) If no, return -1


TC : O(N) , where N = max length of the linked list
SC : O(1)

1) Global variables are public variables that are defined in the global scope. To use the variable in the global scope inside a function, we use the global keyword.

2) Protected attributes are attributes defined with an underscore prefixed to their identifier eg. _sara. They can still be accessed and modified from outside the class they are defined in but a responsible developer should refrain from doing so.

3) Private attributes are attributes with double underscore prefixed to their identifier eg. __ansh. They cannot be accessed or modified from the outside directly and will result in an AttributeError if such an attempt is made.

Self is used to represent the instance of the class. With this keyword, you can access the attributes and methods of the class in python. It binds the attributes with the given arguments. self is used in different places and often thought to be a keyword. But unlike in C++, self is not a keyword in Python.

1) Arrays in python can only contain elements of same data types i.e., data type of array should be homogeneous. It is a thin wrapper around C language arrays and consumes far less memory than lists.

2) Lists in python can contain elements of different data types i.e., data type of lists can be heterogeneous. It has the disadvantage of consuming large memory.

Python library offers a feature - serialization out of the box. Serializing an object refers to transforming it into a format that can be stored, so as to be able to deserialize it, later on, to obtain the original object. Here, the pickle module comes into play.

Pickling:
Pickling is the name of the serialization process in Python. Any object in Python can be serialized into a byte stream and dumped as a file in the memory. The process of pickling is compact but pickle objects can be compressed further. Moreover, pickle keeps track of the objects it has serialized and the serialization is portable across versions.
The function used for the above process is pickle.dump().


Unpickling:
Unpickling is the complete inverse of pickling. It deserializes the byte stream to recreate the objects stored in the file and loads the object to memory.
The function used for the above process is pickle.load()

The init method works similarly to the constructors in Java. The method is run as soon as an object is instantiated. It is useful for initializing any attributes or default behaviour of the object at the time of instantiation.

Inheritance gives the power to a class to access all attributes and methods of another class. It aids in code reusability and helps the developer to maintain applications without redundant code. The class inheriting from another class is a child class or also called a derived class. The class from which a child class derives the members are called parent class or superclass.

Python supports different kinds of inheritance, they are:

1) Single Inheritance: Child class derives members of one parent class.

2) Multi-level Inheritance: The members of the parent class, A, are inherited by child class which is then inherited by another child class, B. The features of the base class and the derived class are further inherited into the new derived class, C. Here, A is the grandfather class of class C.

3) Multiple Inheritance: This is achieved when one child class derives members from more than one parent class. All features of parent classes are inherited in the child class.

4) Hierarchical Inheritance: When a parent class is derived by more than one child class, it is called hierarchical inheritance.

If you get this question, it's an opportunity to choose the most compelling information to share that is not obvious from
your resume.

Example :

Strength -> I believe that my greatest strength is the ability to solve problems quickly and efficiently, which makes me
unique from others.

Ability to handle Pressure -> I enjoy working under pressure because I believe it helps me grow and become more
efficient.


Tip : Emphasize why you were inspired to apply for the job. You can also explain that you are willing to invest a great
deal of energy if hired.

These are generally very open ended questions and are asked to test how quick wit a candidate is. So there is
nothing to worry about if you have a good command over your communication skills and you are able to propagate
your thoughts well to the interviewer.

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.

Tip 4 : Since everybody in the interview panel is from tech background, here too you can expect some technical
questions. No coding in most of the cases but some discussions over the design can surely happen.