Explore topic-wise InterviewSolutions in .

Suppose ASSUME the table is in the format shown below,:

Employee table:

To FIND the maximum salary,

To find the average salary,

To find the MINIMUM salary,

• Free Mock CODING Interview
• DSA Tutorial
• Coding Interview Questions for Practice
• Technical Interview Questions for Practice
• Interview Preparation

• The major difference between List and Tuple in PYTHON is that List is mutable whereas Tuple is immutable. Mutable means the structure or content can change after it is created whereas Immutable means the structure or content cannot be CHANGED after it is created.
• With the property of Immutability, Tuple is more memory efficient than List which means Tuple takes less memory than List because as List is mutable python needs to allocate more space as we can potentially add more entries to it.
• A tuple is also time-efficient because of the same property's Immutability. It takes less time for instantiating a new Tuple over List. Also, it takes less time to lookup in a Tuple than a List. Although the time difference isn't LARGE it is worthwhile to note.
• The list has higher flexibility than Tuple as we can add new elements delete existing elements etc easily but as Tuples are immutable adding a new element or deleting existing elements means that we NEED to create a new Tuple with the new addition or deletion.

• Vector is resizable whereas Arrays are fixed. When the array reached its CAPACITY then the array won't extend implicitly but the vector implicitly extends its size by reallocating the elements by allocating more space.
• Arrays have to be explicitly deallocated (if allocated dynamically) whereas vectors get automatically deallocated when it gets out of scope.
• We NEED to manually keep track of the size of the dynamically allocated array explicitly whereas the size of the vector doesn't need to be TRACKED. This also means that we need to explicitly pass the size of the dynamically allocated array along with the array to a function (if we need to do some OPERATIONS in that function) but we don't need to pass the size of the vector to a function.
• We cannot copy or assign the array to another array but we can copy or assign the vector to another vector easily.

#include <iostream>using namespace STD;class MyClass{};int main() { COUT<<sizeof(MyClass)<<"\n"; }// Output:// 1

The size of an empty class in C++ is 1 byte. The reason BEHIND this is to make SURE that 2 different objects have 2 different addresses. If they have the same addresses then there is no way to differentiate whether two objects are the same or different. It all boils down to the identity of the object.

This can be done in many WAYS. But the more pythonic WAY of doing this is to use filter and lambda.

filter() method takes a function and a sequence. The function should return true or false. It runs a function on each element in the sequence and returns an iterator for the elements for which the function returns true.

We can pass a normal function to filter but the more pythonic way of doing it is to pass a lambda.

class MYCLASS: def __init__(self): self.x=10 self.__y=20 obj=myClass()print(obj.__y)

Private name mangling: When an identifier that textually occurs in a class definition begins with TWO or more underscore characters and does not END in two or more UNDERSCORES, it is considered a private name of that class. Private names are transformed to a longer form before code is generated for them. The transformation inserts the class name in FRONT of the name, with leading underscores removed, and a single underscore inserted in front of the class name. For example, the identifier __spam occurring in a class named Ham will be transformed to _Ham__spam.

Hence the above example throws an error 'AttributeError: myClass object has no attribute __y' because the name is transformed into _myClass__y. So if we instead print(obj._myClass__y), this will work and prints 20.

Most people try to divide the coins into 2 groups. But the TRICK here is to divide them into 3 groups. The reason being if we divide coins into 2 groups and weigh them, we can only discard one group. But if we divide them into 3 groups and weigh 2 groups, either they both will be equal or not. If both are equal then the coin with heavier weight will be on the LEFT out group and if they both are not equal then the heavier weight group contains the coin with heavier weight. We can discard 2 groups out of the 3 groups in this case.  Hence we first divide 9 coins into 3 equal groups.

• In the first iteration, we can discard 2 groups out of them using the above concept.
• We will be left with 3 coins now.
• Now we again divide them into 3 equal groups with 1 coin in each group.
• In the second iteration, we can again discard 2 groups and hence will be able to find the heavier coin.
• So, it TAKES only 2 ITERATIONS to find out the heavier coin.

BOOTSTRAP is an Open Source Front-End framework developed by Twitter that is used for making web development easier and faster. This is NOTHING but a reusable code that we can freely download and use for our own web development so that we get the functionality without having to re-write the same code (i.e., not inventing the wheel again). It supports ALMOST all of the browsers and hence can WORK with any browser.

Bootstrap also makes the website responsive i.e., they fit the screen no matter which device is being used to view the website.

Advantages of Bootstrap over CSS:

• Time-Saving: It increases the development speed as we can achieve the same functionality by using the bootstrap in our code instead of writing the code from scratch.
• Cross-Browser COMPATIBILITY: As bootstrap supports all of the major modern web browsers, we don't need to worry about whether a functionality runs on all modern web browsers or not.
• Responsiveness: As bootstrap uses a fluid grid layout, it adapts to the screen resolution of the device and hence we won't get a surprising website view when opening the same website on different devices of different sizes like a laptop, desktop, mobile, tablet etc
• Ease of Use: With just basic knowledge of HTML and CSS, we can start using bootstrap easily.
• Open Source: Bootstrap is available for free and hence we don't need to pay to get this functionality.

To print 1-100 without LOOP, we can leverage RECURSION for this.

Let us see what for does. 

for loop does 3 things, initialization, condition check and expression to evaluate before running the next iteration. These 3 things are separated by a semicolon (;). Whatever logic is needed inside for loop is placed inside { } parenthesis. If we have a SINGLE line body then this single line can follow for loop without having the { } parenthesis. One more thing to note is that when the condition check is empty, it is replaced by a non-zero constant by the compiler.

Here, in this case, the initialization is empty, condition check is empty and the expression to evaluate before running the next iteration is also empty and has a single line body of the print statement.

As the condition is replaced by a non-zero constant by the compiler, it is always evaluated to true and hence the loop runs on forever. So an INFINITE loop printing Hello on the SCREEN.

A dangling pointer is a pointer pointing to a location that was already FREED. De-referencing a dangling pointer causes undefined behaviour.

For example:

In the above example, the secondPtr which points to the same address the firstPtr is pointing to gets deleted and hence later when firstPtr is dereferenced, it gives undefined behaviour. Here the firstPtr becomes a dangling pointer as it is still pointing to the MEMORY that got deleted.

To avoid having dangling POINTERS, we can use smart pointers (or) check all the pointers that are being referenced and explicitly make them NULL so that they don't point to the deleted memory.

Volatile is a keyword in C that tells the compiler not to optimize anything that is related to the volatile variable and always fetch the value of the variable from the memory for every use of the volatile variable.

For example, 

In this case, the compiler sees that the variable run is not being used at all in the loop and hence can optimize the while loop into while(1). But run can be changed by a signal handler or OS etc. If we make the variable run as volatile, then the compiler doesn't do any such optimization.

The 3 major places where volatile is used (i.e., variable can change without action from visible CODE) is:

• Interface with hardware that changes the value itself (I/O MAPPED memory LOCATION).
• Another thread running that also uses the same variable.
• A signal handler that might change the value.

Palindrome: A string is called a palindrome if it can be read the same way starting from the front (or) starting from the back. In other words, a string is a palindrome if the reverse of the string is equal to the original string.

Naive Implementation: 

Output:

This approach has a Time Complexity of O(N) and ALSO Space Complexity of O(N).

A better version to solve this is to not create the actual copy but use 2 pointers one from start and another from the end to check if these 2 pointers POINT to the same characters and move them until the midpoint of the string.

Output:

This approach has a Time Complexity of O(N). Space Complexity is O(1) as we are not making a copy of the string here. 

Merge Sort is a Divide & Conquer algorithm that is used to sort a given INPUT (can be an ARRAY or linked list). It involved dividing the input into 2 halves at each step until input has only 1 element and then merging these sorted halves to finally get a sorted input.

Merge sort is not an in-place algorithm (which means you NEED to use extra SPACE for sorting the input). 
Merge sort is a stable algorithm which means if there are 2 same elements in the input, the sorted output will maintain the relative ordering of these elements.

• Time Complexity: O(NLogN) even in the WORST case. (where N is the size of the input)
• Space Complexity: O(N)

Data STRUCTURES are divided into 2 types based on the shape/ based on the arrangement of the data elements. They are Linear Data Structures and Non-Linear Data Structures.

• Binary Tree: A Binary Tree is a tree in which each NODE can have at most 2 children. The children are named left child and right child. There is no CONSTRAINT on the VALUE the node or its children can have. We need to traverse the whole tree for searching in the case of a binary tree.

• Binary Search Tree: Binary Search Tree (BST) is a Binary Tree but with an additional constraint that the left subtree of a node can only have NODES whose values are less than the parent node's value & the right subtree of a node can only have nodes whose values are GREATER than parent node's value.  We need to traverse only the height of a tree (in the worst-case scenario) for searching in the case of a Binary Search Tree.