SDE - 1

It can be solved by using mathematics. If the height of wall is less than or equal to x, only one jump is required. Otherwise run a while loop while height is greater than x, and calculate the jumps required by updating the height to height of wall – (climb up-climb down).

The naïve approach is to generate all substrings of string1 and for each substring, check whether the substring contains all characters of string2. Finally, print the smallest substring containing all characters of string2.

The efficient solution is to use hashing. First check if the length of the string is less than the length of the given pattern, if yes then no such window can exist . Next, store the occurrence of characters of the given pattern in a array, say h_pat[]. Now use two pointer technique :
1. Start matching the characters of pattern with the characters of string , keep incrementing count if a character matches.
2. Check if (count == length of pattern string), if it matches then this means a window is found.
3. If such a window is found, try to minimize it by removing extra characters from the beginning of the current window.
4. Delete one character from first and again find this deleted key at right, once found apply step 2.
5. Update minimum length.
At last, print the minimum length window.

Steps: 
1. Start from the cell[0,0] and look for the valid moves through the adjacent cells in the order Down->Left->Right->Up in the grid.
2. If the move is possible, then move to that cell while storing the character corresponding to the move(D,L,R,U) and again start looking for the valid move until the last cell [n-1,n-1] is reached.
3. Along with it, keep on marking the cells as visited and when all the paths possible are traversed from that cell, then unmark that cell for other different paths and remove the character from the path formed.
4. As soon as the last index [n-1,n-1] of the grid is reached, store the traversed path.

A C++ virtual function is a member function in the base class that you redefine in a derived class. It is declared using the virtual keyword. It is used to tell the compiler to perform dynamic linkage or late binding on the function. A 'virtual' is a keyword preceding the normal declaration of a function. When the function is made virtual, C++ determines which function is to be invoked at the runtime based on the type of the object pointed by the base class pointer.

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.

A shallow copy of a collection is a copy of the collection structure, not the elements. With a shallow copy, two collections now share the individual elements.
Deep copies duplicate everything. A deep copy of a collection is two collections with all of the elements in the original collection duplicated.

Make sure you study their website inside-out before you go for interviews, this shows your passion to work for their company. Be yourself.