IBM Interview Questions

Procedural programming is a programming model that evolved from structured programming and is based on the concept of invoking procedures. Procedures, often known as routines, subroutines, or functions, are essentially a set of instructions to be executed. Any procedure in a program can be invoked at any time during execution, either by other procedures or by the program itself.

The following table illustrates the differences between procedural programming and object-oriented programming:

 Schedulers are specialised computer programs that manage process scheduling in a variety of ways. Their primary responsibility is to choose which jobs to submit into the system and which processes to run.

Following are the three types of schedules:

• Long Term Scheduler: It is also known as a job scheduler. A long-term scheduler determines which programs are accepted for processing into the system. It chooses processes from the ready queue and loads them into memory so they can be executed. For CPU scheduling, the process loads into memory. The job scheduler's main goal is to deliver a balanced mix of jobs, such as I/O bound and CPU bound workloads. It also regulates how much multiprogramming is done. If the degree of multiprogramming remains constant, the average rate of process creation must be equal to the average rate of process departure from the system.
• Medium Term Scheduler: Medium Term Schedulers are used for swapping processes in the main memory. It clears the memory occupied by the processes. The degree of multiprogramming is reduced as a result. The swapped out-processes are handled by the medium-term scheduler.
• Short Term Scheduler: It's also referred to as a CPU scheduler. Its primary goal is to improve system performance in accordance with the set of criteria established. It is the transition from the process's ready to running stage. The CPU scheduler chooses a process from among those that are ready to run and allocates CPU to that process. Short-term schedulers usually referred to as dispatchers, decide which process to run next.

Virtual Memory is a storage allocation system that allows secondary memory to be addressed as if it were the main memory. The addresses used by an application to refer to memory are distinct from the addresses used by the memory system to designate physical storage sites, and program-generated addresses are automatically translated to machine addresses.

The capacity of virtual storage is limited by the computer system's addressing method, and the amount of secondary memory available is determined by the number of main storage sites available rather than the actual number of main storage locations.

sudo is a short form of Super Users DO. In Linux, the sudo command is commonly used as a prefix to a command that only superusers are permitted to run. If you use the prefix "sudo" before any command, it will run it with elevated privileges, allowing a user with the necessary permissions to run a command as another user, such as the superuser. This is the Windows version of the "run as administrator" option. 

The sudoers file, stored at "/etc/sudoers," must contain an entry for each user who may use the sudo command. Remember to use the sudo command to edit or inspect the sudoers file. The "visudo" command is suggested for editing the sudoers file.

Example:
Input :
N = 4, C = { 1, 2, 3}
Output : 
4
Explanation:
There are 4 possible combinations : {1, 1, 1, 1}, {1, 1, 2}, {1, 3}, {2, 2}

Input :
N = 10, C = {2, 3, 5, 6}
Output :
5
Explanation:
There are 5 possible combinations ; {2, 2, 2, 2, 2}, {2, 2, 3, 3}, {2, 2, 6}, {2, 3, 5}, {5, 5}

Approach:

We can divide all set solutions into two sets to count the total number of solutions.

1) Solutions that are devoid of the mth coin (or Cm).

2) At least one Cm is present in the solution.

If solve(C[], m, n) is the function for counting the number of solutions, it may be represented as the sum of solve(C[], m-1, n) and solve(C[], m, n-Cm). We will use dynamic programming to store the result for a particular value of n and m. This will optimise our time complexity to O(nm).

Code:

 #include<bits/stdc++.h>
using namespace std;
// function to count the number of ways n can be represented from a coin set of size m
int solve( int C[], int m, int n )
{
    int dp[n + 1][m];//Creating a 2D matrix of size (n + 1) 8 m to store the result of each state of our problem
     
    // Filling the matrix for the base case when n = 0
    for (int i = 0; i < m; i++)
        dp[0][i] = 1;
 
    // Filling the entries in the dp table in bottom up fashion
    for (int i = 1; i < n + 1; i++)
    {
        for (int j = 0; j < m; j++)
        {
            // Including C[j] in our current state's answer
            int x = (i-C[j] >= 0) ? dp[i - C[j]][j] : 0;
 
            // Excluding C[j] in our current state's answer
            int y = (j >= 1) ? dp[i][j - 1] : 0;
 
            // storing the sum of x and y in our current state's answer
            dp[i][j] = x + y;
        }
    }
    return dp[n][m - 1];
}
 
int main()
{
    int C[] = {2, 3, 5, 6};
    int m = sizeof(C)/sizeof(C[0]);
    int n = 10;
    cout << solve(C, m, n);
    return 0;
}

Output:

 5

Explanation:

In the above code, we define a function named ‘solve’ which returns the number of ways in which n can be represented from a set of m coins having distinct values. We create a dp table of size (n+1) * m. dp[i][j] represents the number of ways in which i can be represented by a set of j coins. Here, we have used the recurrence formula dp[i][j] = x + y. Here, x = dp[i - C[j]][j], y = dp[i][j-1].

Input :
“inTerVieWbiT”
Output :
“INtERvIEwVIt”

Input :
“Hello World”
Output :
“hELLO wORLD”

Approach:

We scan each character of the string one by one. If the current character is in lowercase, we subtract 32 from the character and convert it to uppercase. Similarly, if the current character is in uppercase, we add 32 to the character and convert it to lowercase.

Code:

 #include <iostream>
using namespace std;
 
// Function to convert the characters of the string to its opposite case
void changeCase(string& s)
{
    int len = s.length();
    for (int i = 0; i < len; i++) {
        if (s[i] >= 'a' && s[i] <= 'z')
        {
            s[i] = s[i] - 32;// Subtracting 32 from the character
        }      
        else if (s[i] >= 'A' && s[i] <= 'Z')
        {
            s[i] = s[i] + 32;// Adding 32 to the character 
        }        
    }
}
 
int main()
{
    string s = "inTerVieWbiT";
    cout << "Original String : " << s << "\n";
    changeCase(s);
    cout << "Changed String : " << s << "\n";
    return 0;
}

Output:

Original String : inTerVieWbiT
Changed String : INtERvIEwBIt

Explanation :

In the above code, we define a function named ‘changeCase’ which takes a reference of a string as a parameter. We iterate through each character of the string and change the character to its opposite case by either adding or subtracting 32. 

Example:
Input: 
arr = {0, 0, 0, 0, 1, 1, 1}
Output :
4

Input :
Arr = {0, 0, 0, 0}
Output :
-1 

Approach:

It is given that the array is sorted. We use this property of the array and apply binary search to find the first occurrence of 1 in the given array. We start with the whole array as our search space and find the middle element. If we encounter 0 as the middle element, it implies that our answer lies to the right side of the middle element. If we encounter 1 as the middle element, our answer can either be this index or the indices left to the current middle if there are more 1s preceding the current middle.

Code:

 #include <bits/stdc++.h>
using namespace std;
 
// function to find the first occurrence of 1 in the give sorted array
int findIndex(int arr[], int low, int high)
{
    while (low <= high) {
        int mid = low + (high - low) / 2;
 
        // we check if the mid element is a 1 and the mid - 1 element is 0
        if (arr[mid] == 1 && (mid == 0 || arr[mid - 1] == 0))
            return mid;
 
        // our answer lies to the left of mid, we reduce our search space
        else if (arr[mid] == 1)
            high = mid - 1;
 
        // our answer lies to the right of mid, we reduce our search space
        else
            low = mid + 1;
    }
 
    // we return -1 since 1 is not present in the array
    return -1;
}
 
int main()
{
    int arr[] = { 0, 0, 0, 0, 1, 1, 1, 1 };
    int n = sizeof(arr) / sizeof(arr[0]);
    cout << findIndex(arr, 0, n - 1);
    return 0;
}

Output:

 4

Explanation : 

In the above code, we defined a function named ‘findIndex’ which finds the first occurrence of the first one in the sorted array. We reduce the search space by changing the values of low and high as per the current value of the middle element. If low exceeds high, we return -1 which indicates that no 1 is present in the array.

An entry control loop examines the condition at the point of entry and passes control to the body of the loop if the condition or expression becomes true.

The name "entry control loop" comes from the fact that this sort of loop regulates loop entry.

for loops and while loops are examples of entry controlled loops.

 Following are the differences between quick sort and merge:

A deadlock occurs when a group of processes is halted because each process is holding a resource and waiting for another process to obtain it.

Consider the situation when two trains are approaching each other on the same track and there is only one track: once they are in front of each other, neither train can move. In operating systems, a similar situation happens when two or more processes hold some resources while waiting on resources owned by other processes (s). 

For example, let us assume that there are two trucks trying to cross a one-way bridge from opposite ends. None of the trucks is ready to move back and neither can any of them cross the bridge. In this situation, a deadlock has been obtained.

Following are the necessary conditions for a deadlock :

• Mutual Exclusion: One or more resources are not available for sharing. That is, only one process can use the resource at a time.
• Hold and Wait: A process is holding at least one resource and waiting for further resources.
• No Preemption: A resource can only be obtained from a process if it is released by the process. There can be no forced snatching of the resources.
• Circular Wait: A group of processes are waiting for each other in a circular fashion.

A collection of items stored in contiguous memory spaces is referred to as an array. The objective is to group together goods of the same type. This makes calculating the position of each element easy by simply adding an offset to a base value, such as the memory address of the array's first element.

Following are the real-life applications of an array:

• Arrays can be used to store data in a tabular style as a simple application. For example, if we want to save our contacts on our phones, the software will simply create an array with all of our contacts.
• The arrangement of a game's leaderboard may be done simply by using arrays to record the score and arranging them in descending order to clearly see each player's rank in the game.
• A straightforward question paper consists of an array of numbered questions, each of which is assigned a set of marks.
• In image processing, 2D arrays, often called matrices, are used.
• It's also used in speech recognition, where each spoken signal is represented by an array.

The purpose of a variable declaration is to tell the compiler of the following information: the variable's name, the kind of value it stores, and the initial value if any. Declaration, in other words, provides information about a variable's attributes. The definition of a variable allocates memory space for the variable and specifies where the variable will be stored.

The following table illustrates the differences between definition and declaration:

void fun()
{
   cout << “Hello World” << “\n”;
}

void fun();

• struct: In C, a structure is a user-defined data type that allows you to combine data objects of various types. A record is represented by a structure.

Syntax:

 struct structureName
   {
       member definition;
       member definition;
       ...
       member definition;
   }; 

• union: In C, a union is a unique data type that allows you to store many data types in the same memory region. A union can have numerous members, but only one of them can have a value at any given time. Unions are a useful approach to reuse the same memory space for numerous purposes.

Syntax:

 union unionName
    {
       member definition;
       member definition;
       ...
       member definition;
    };

The following table illustrates the differences between struct and union:

In a SQL Database, every transaction must follow some specific set of properties. These properties are referred to as ACID properties. They are as follows:

• A for Atomicity: This means that either the complete transaction occurs at once or it does not occur at all. There is no middle ground, which means that transactions do not take place in stages. Each transaction is treated as a single entity that is either completed or not conducted at all. It entails the following two procedures.
  • Abort: If a transaction aborts, any database modifications are lost.
  • Commit: When a transaction commits, the changes it contains become visible.
    The 'All or nothing rule' is another name for atomicity.
    For example, consider a bank transaction from one account to another. The transaction must either be completed entirely or must be failed. There cannot be a midway transaction such as money has been debited from one account but has not been credited to the other account.
• C for Consistency: This property implies that integrity constraints must be fulfilled before and after the transaction to ensure that the database is consistent. It refers to a database's correctness. 
  For example, if a bank transaction is performed from account A having X money to an account B having Y money, then after the transaction has been performed the total amount of money must remain the same, that is, X + Y.
• I for Isolation: This attribute assures that several transactions can take place at the same time without causing database state inconsistencies. Transactions take place in a non-interfering manner. Changes made in one transaction are not visible to other transactions until that transaction's update is written to memory or committed. This feature assures that concurrently executing transactions results in a state that is identical to the one attained if they were executed sequentially in some order.
  For example, a bank has many ATMs present in a country. All of the ATMs can operate at the same time. They function as if they are the only transaction being performed on the bank’s database thereby, implementing isolation.
• D for Durability: This attribute ensures that once a transaction has completed execution, the database updates and modifications are saved and written to memory and that they survive even if the system fails. These modifications are now saved in non-volatile memory and are permanent. As a result, the transaction's effects are never lost.
  For example, a backup database must be maintained so that if in any case, the primary database fails, we can recover the data from the backup database.

A database management system is a piece of software that manages databases. Examples of database management systems include MySQL, Oracle, and other commercial databases. A database management system (DBMS) provides an interface for doing tasks such as building a database, saving data in it, updating data, and creating a table in the database, among others. It ensures the database's safety and security. It also ensures data consistency when there are multiple users.

Following are the advantages of a database management system over traditional file systems :

• Better Data Management: Database management makes it possible for users to access better-managed data. As a result, end-users will be able to take a quick check at their data and respond quickly to any changes.
• Enhanced Data Security: As the number of users grows, the rate at which data is transferred or shared grows as well, raising the danger of data security. It is frequently used in the corporate sphere, where organisations devote a significant amount of money, time, and effort to assure data security and proper use. A Database Management System (DBMS) helps firms improve data security by providing a better platform for data privacy and security regulations.
• Reduced Data Inconsistency: In a database management system, data inconsistency is minimised when various versions of the same data appear in different places. For example, data inconsistency occurs when a student's name is saved as "William Shakespeare" on the school's main computer, while the same student's name is saved as "W. Shakespeare" on the teacher's registered system.
• Faster data access: The database management system (DBMS) aids in the production of speedy responses to database queries, allowing for faster and more accurate data access. End users, for example, will have improved access to data while dealing with massive amounts of sales data, allowing for a speedier sales cycle.

• Process: Any program in execution is referred to as a process. Any process is controlled by a process control block. Process priority, process id, process state, CPU, register, and other information are all stored in the Process Control Block (PCB). Child Processes are created when a process spawns another process. It takes longer for a process to end, and it is isolated, which means it doesn't share memory with other processes.
• Thread: A thread is a section of a process, which means that a process can have several threads, all of which are contained within the process. A thread can be in one of three states: running, ready, or blocked. Threads require less time to terminate than processes, but they do not isolate like processes.

The following table illustrates the differences between them:

• Primary/Main Memory: The computer memory that is directly accessible by the CPU is referred to as primary memory. It is made up of DRAM (Dynamic Random Access Memory) and provides the processor with an actual working area. It keeps track of the data and instructions that the processor is currently processing. Example - RAM (Random Access Memory)
• Secondary Memory: Because the processor does not directly interface with the secondary memory, the contents of the secondary memory are first transferred to the primary memory and then accessed by the processor. Example - Hard disk, USB drive, etc.

The following table illustrates the differences between primary memory and secondary memory:

Following are the functions of an operating system :

• Provides user interface: Operating systems provide an interface between computer hardware and the users. It makes it easy for the user to access the hardware in a systematic manner.
• Maintains system performance: Helps increase performance by monitoring overall system health. To get a thorough picture of the system's health, keep track of the time between service requests and system responses. This can aid performance by providing critical information for troubleshooting issues.
• Security: To safeguard user data, the operating system employs password protection and other similar measures. It also protects applications and user data from illegal access.
• Error-detection: The operating system constantly monitors the system in order to detect errors and prevent a computer system from failing.
• Memory Management: The primary memory, often known as main memory, is managed by the operating system. The main memory consists of a vast array of bytes or words, each of which is allocated an address. Main memory is rapid storage that the CPU can access directly. A program must first be loaded into the main memory before it can be executed. For memory management, an operating system performs the following tasks:
  • It keeps track of primary memory, i.e., which user programmes use specific bytes of memory. Memory addresses that have already been assigned, as well as memory addresses that have yet to be used.
  • The OS determines the order in which processes are permitted memory access and for how long in multiprogramming. It allocates memory to a process when the process asks for it and deallocates memory when the process exits or performs an I/O activity.
• Processor Management: In a multiprogramming environment, the operating system determines the sequence in which tasks access the processor and the amount of processing time each process has.
• Device Management: An operating system (OS) controls device connectivity through drivers. It keeps track of all the devices that are linked to the system. The Input/Output controller is a program that is responsible for all devices. Determines which processes are allowed access to a device and for how long. Allocates devices in a way that is both effective and efficient. When a gadget is no longer needed, it is deallocated.
• File Management: A file system is divided into directories to make navigation and usage more efficient. Other directories and files may be found in these directories. The operating system keeps track of where data is kept, user access settings, and the state of each file, among other things.

• Function Overloading: 

It allows for multiple definitions of the function by modifying the signature, i.e. the number of parameters, the datatype of the parameters, and the return type.

For example:

using namespace std;
 
// Method 1
void overloadedMethod(int x)
{
    cout << "In Overloaded Method 1" << endl;
}
 
// Method 2
void overloadedMethod(float x)
{
    cout << "In Overloaded Method 2" << endl;
}
 
// Method 3
void overloadedMethod(int x1, float x2)
{
    cout << "In Overloaded Method 2" << endl;
}
 
int main()
{
    int x = 5;
    float y = 5.5;
    overloadedMethod(x);
    overloadedMethod(y);
    overloadedMethod(x, y);
 
    return 0;
}

Output:

In Overloaded Method 1
In Overloaded Method 2
In Overloaded Method 3

Explanation:

In the above code, we have three functions with the same name and return type. However, they have different function signatures which differentiates them from each other. When we pass a parameter of int type, method 1 gets executed. When we pass a parameter of float type, method 2 gets executed. When we pass both an int and a float type parameter, method 3 gets executed.

• Function Overriding:

It is the redefining of a base class function in a derived class with the same signature, that is, the return type and parameters. It's only possible in derived classes. 

 class Test
{
public: 
      virtual void print(){ cout << "Test Function"; }
};

class Sample : public Test
{
public: 
       void print(){ cout << "In Sample Function";}
};
int main()
{
    Test obj = new Sample();
    obj.print();
    return 0;
}

Output:

 In Sample Function

In the above code, the class Sample extends the class Test and therefore inherits all its properties. We can clearly see that both the classes have a function ‘print’ with the same function signature and return type. Therefore, the above code implements function overriding. Since we have added a virtual keyword in the function of the base class, the function is called according to the type of object being referred to and so the print function of the Sample class gets called.

The following points illustrate the differences between function overloading and function overriding:

• When one class inherits from another, it causes overriding of functions. Overloading can happen in the same class.
• Overloaded functions must have a different function signature, which means they must have a different number of parameters or a different type of parameter. Function signatures must be identical when overriding.
• Overloaded functions are present in the same scope of a class while overridden functions are present in different scopes.

There are four major concepts in Object-Oriented Programming. They are as follows:

• Encapsulation: Encapsulation is described as the binding of data and the functions that alter it in Object-Oriented Programming. Encapsulation makes a class's variables or data concealed from other classes and that they can only be accessible through member functions of the class in which it is stated.
  Let us consider the following example: 
  In a company, there are different divisions such as accounts, finance, sales, and so on. The finance department’s duty is to keep track of all financial data and the transactions performed on them. Similarly, the sales department’s duty is to keep track of all sales-related activities. 
  Let us assume that an official from the finance department requires the sales data for a specific month. In this scenario, he cannot access the sales section's data directly. An official from the sales department must be contacted because only he can access the data. Here, the process of asking the sales officials for the data depicts encapsulation. The sales department's data and the people who can influence it are bundled together under the category "sales section."
• Abstraction: Abstraction refers to revealing only the most important information while concealing the details. Data abstraction refers to exposing only the most important aspects of the data to the outside world while concealing the implementation specifics.
  Consider the case of a man driving a vehicle. The man only knows that pressing the accelerators will increase the vehicle's speed and that applying the brakes will stop it, but he has no idea how the speed is increased by pressing the accelerators, nor does he understand the car's inner mechanism or how the accelerator, brakes, and other controls are implemented in the car. This is the definition of abstraction.
• Inheritance: Inheritance refers to a class's capacity to derive features and traits from another class. One of the most significant characteristics of Object-Oriented Programming is inheritance. A class that inherits properties from another class is referred to as a subclass or a derived class. A class whose properties and member functions are inherited by other classes are referred to as superclass or base class. Inheritance supports the concept of "reusability".
  Consider a class Vehicle that contains all the essential functions which a vehicle must possess. This includes accelerating speed, applying brakes, changing gear and so on.
  Now let us assume the classes Car, Bus, Truck and so on. All of these classes can be considered as a subclass of the class Vehicle since all of them must essentially possess all the properties of the class Vehicle.
• Polymorphism: Polymorphism refers to the fact that something exists in multiple forms. Polymorphism, in simple terms, is the ability of a message to be displayed in multiple formats. For example, at the same time, a person might have a variety of characteristics. At the same time, he is a father, a spouse, and a worker. As a result, the same person behaves differently in different settings. Polymorphism is the term for this.
  There are mainly two types of polymorphism in C++. They are as follows:
  • Compile Time Polymorphism: Function overloading and operator overloading is used to achieve this form of polymorphism.
  • Runtime Polymorphism: Function Overriding is used to generate this form of polymorphism.

In such types of questions, mention your strong points and the skills you possess which makes you a good fit for the role. A sample answer to the question could be as follows:

“For various reasons, I am certain that I am a suitable fit for this role, but most notably because of my commitment to going above and beyond in my work. To succeed in this role, I am committed to learning any new abilities on my own. My abilities and skills are a perfect match for the prerequisites for this post. My communication and leadership abilities, in particular, make me a strong contender for the position.”

IBM assesses a candidate thoroughly in both technical and interpersonal domains before making any hiring decisions. Therefore, getting an internship at IBM should not be considered as a piece of cake. However, with the right preparation and the right attitude, one can easily crack an internship at IBM. The only thing required is the right path and guidance.

Yes, IBM does hire interns.

The average salary for freshers at IBM ranges from Rs. 2.2 lakhs per year to Rs. 7.3 lakhs per year.

In such types of questions, mention the things which motivate you to work for the company. Try to highlight the values and the motto which the company believes in as part of your motivation to join the company. 

The following could be a sample answer:

“I'd like to work with IBM because IBM has a strong set of principles and a clear commitment to not only your staff but also to your customers and clients. This is an organisation where I will be able to grow, thrive, and develop over time, and I will have the opportunity to work with an incredibly brilliant group of people who are all dedicated to the IBM brand's long-term success. I see this as a once-in-a-lifetime opportunity to put my abilities and traits to good use.”

The interviews at IBM focus on the candidate’s understanding of the basic fundamentals. With the right preparation, IBM interviews are definitely easy to crack.

At International Business Machines, the employment procedure can take anywhere from two weeks to ten months. Because of the large number of applicants, the screening procedure takes a bit longer before the best candidates are chosen.