TCS Ninja Interview Questions 2024

The 4 pillars of object-oriented programming are encapsulation, abstraction, inheritance, and polymorphism.

1. Abstraction: Abstraction means hiding the details from the user. For instance, when we build any application, we only let the user interact with it using buttons. We never let the user know what happens behind the clicks of the buttons.

2. Encapsulation: As the name suggests, this means encapsulating different kinds of data into a single entity. For instance, when we make a class, we encapsulate the data and member functions into that single class.

3. Inheritance: When a class inherits from another class, it shares the properties of the first class. For example, if we make a Student class, it inherits the class People as a student have all the properties of People like a student walks, talks, etc.. and apart from It, the Student has its own properties like enrollment number, subjects. etc.

4. Polymorphism:: The word "poly" means many and the rod "morph" means form. This means that polymorphism means showing many forms. Polymorphism can be run-time or compile-time.

Examples of polymorphism are function overloading and function overriding.

Yes, C++ is an Object-Oriented programming language as we can create classes and objects and C++ can implement all the 4 pillars of OOPS. However, C++ is not a purely object-oriented

programming language. This is because a purely object-oriented programming language is such a language where all the functions are written inside a class and there are no primitive data types. Everything is an object in a pure object-oriented programming language.

The solution is using the XOR operator. Following is the c++ code for the same.

C++ Program

# include <algorithm>
# include <iostream>
# include <vector>
using namespace std
void swap (int &x. int &y) {
    x = x^y;
    y = x^y;
    x = x^y;
}
int main() {
    // Your code goes here;
    int x,y;
    cin >>x>>y;
    cout<<"Before swapping.x = "<< x <<" y = "<<y<<"";
    swap(x,y);
    cout<<"After swapping,x ="<<x<<" y = "<<y<<" ";
    return 0;
}

Sample Input:

10 20

Sample Output:

Before swapping,x = 10 y = 20

After swapping,x = 20 y = 10

The binary search algorithm is used to find an element in a sorted array. It is an optimized searching algorithm as the linear search scans all the elements of the array and the searching time for the linear search thus becomes O(N). However, the searching time of Binary Search is O(log2N). This is because in an average case, only log2N elements of an array are compared. We start by checking the middle element of the array. If the middle element of the array is our answer, we have found the element. If the number that we are searching for is greater than the middle element, it will be on the right half of the array as the array is sorted. So apply binary search on the right half. If the number that we are searching for is smaller than the middle element of the array, we will apply the binary search on the left half of the array. Following is the C++ program for binary search.

C++ Program for Binary Search

#include <algorithm>
#include <iostream>
#include <vector>
using namespace std;
int binarysearch(int arr[], int n, int target) {
    int lo = 0;
    int hi = n-1;
    while(lo <= hi) {
        int mid = lo + (hi-lo)/2;

        if(arr[mid] == target) return mid;
        else if(arr[mid] < target) lo = mid + 1;
        else hi = mid - 1;
    }
    return -1;
}
int main() {
    int arr[] = {10,12,25,36,42,58,97};
    if(binarysearch(arr, 7, 12) == -1) {
        cout << "Element was not found";
    } else {
        cout << "Element was found at index " << binarysearch(arr, 7, 12);
    }
}

Output:

Element was found at index 1

An even number in binary form will always have its Least Significant Bit (LSB) = 0. So, if we take the XOR of this number with 1. the answer will become one greater than the number itself. This is because 0 XOR 1 is 1 so. LSB will become 1 from 0 i.e, increment in the value by 1. So, we can say that if a number (N) is an even number then, if N^1= N + 1 else the number would be an odd number. So, the C++ program to solve the problem is given below.

C++ Program

# include <algorithm>
# include <iostream>
# include <vector>
using namespace std;
bool is_even(int N) {
    if((N^1) ==N + 1) return true;
    else return false;
}
int main() {
    //your code goes here;
    int N;
    cin>>N;
    if(is_even(N)) cout<<"The number is even";
    else cout<<"The number is odd";
}

Sample Input (Even Number):
10
Output:
The number is even
Sample Input (Odd Number);
9
Output:
The number is odd.

Linear Data structures: Arrays, Linked Lists, Stacks, Queues, and Dequeues, are all linear data structures.

Non-Linear Data structures: The non-linear data structures can further be categorized as circular and non-circular. Some circular data structures are Circular Queue. Circular Dequeue, Circular Linked List etc. Some non-circular data structures are Trees, Graphs, Priority queues, etc.

An operating system performs various roles. Some of the examples are as follows:

1. Resource Governor: The OS acts as a resource governor so that there is no load on the system. It allocates and deallocates the resources to the processes and also handles the synchronization of these resources among various processes.

2. Process Management: OS uses various Scheduling algorithms to manage the processes and their execution. This is done to increase the efficiency of the CPU so that it is never idle and the processes keep on executing.

3. Storage Management: OS acts as a storage manager bus using its File System. The data of the user is stored in the foi-m of files and directories.

4. Memory Management: Memory management and storage management are confused with each other. However, the storage management concerns the file system and storage of the data in the Computer, the memory management means managing the memory allocation to the processes at the time of execution, Which process should be kept in the Ready Queue, which is in the Waiting Queue (both these queues are inside RAM only).

5. Privacy and Security: Privacy and security from any threats or viruses are also the responsibility of the OS. However, inter-process security is also the responsibility of the OS.

No, we can't override the private methods. The private methods are those methods that have a scope only within the same class. Since they cannot be accessed outside the class even by a sub-class, there is no way to override the private methods.

Java and C++ are both Object-Oriented Programming languages. However, everything in Java has to be inside a class, whereas this is not the case with C++. C++ has structures that are similar to classes but are used in Procedural Oriented Programming and not Object-Oriented Programming. Java does not have structures. Java has interfaces and C++ does not. Also, in C++ multiple inheritance is supported while it is not supported in Java.

C++ is fast as compared to Java because C++ is a compiled language, whereas Java is a hybrid language i.e. it is both compiled as well as interpreted. Also, Java uses JVM to run whereas C++ runs directly using the 05. Hence. Java is platform-independent whereas C++ is platform-dependent.

Java has Wrapper classes for each primitive data type. So, even though Java is not purely Object Oriented, it is possible to write a pure Object-Oriented Program in Java whereas it is not possible to do so in C++.

DOM stands for Document Object Model. It is an API (Application Programming Interface) that is used to access and change the contents of HTML elements. It provides a hierarchical structure of the web page that makes it easy to access the elements, their parents,their siblings and their children.

In OS, paging is the method of dividing each process into small segments called pages and the main memory is also divided into the frames so that each frame can accommodate one data page. Hence, the relation between pages and frames is

Size of page = Size of frame

TCP stands for Transfer Control Protocol. The TCP is a connection-oriented protocol implemented at the Transport Layer of the OSI Model. TCP is responsible for breaking the data into the form of small frames called framing and later, at the receiver end, it also reassembles the frames back into the sequence to get the data back.

IP stands for Internet Protocol. It is present at the Network Layer of the OSI model. IP is not reliable and it is a connectionless model. IP is responsible for sending and receiving the data that is broken into the form of frames by the TCP. The IP is combined with TCP to form a reliable data sending-receiving Protocol.

The SQL Query to print the current date is: GetDate{}

The SQL Query to do so is

SELECT ‘FROM STUDENTS WHERE NAME = "Rahul"

DCL means Data Control Language. DCL is responsible for managing the access and permissions to a DBMS. DCL helps in deciding which part of the Database should be accessed by which user. The 2 major commands in DCL are:

1. GRANT: This command is used to grant privileges to the Objects of the database for a user. It helps one user to grant certain permissions to the other users.

2. REVOKE: This command is used to withdraw the privileges for the objects of the database that have been granted to a user.

No, constructors are not overridden. The sub-class constructors have to call the super-class constructor for their creation as they inherit from the super-class. Hence, the constructors cannot be overridden.

The main() method, like every other method in Java, is also inside a class. Now, when we compile or run the Java program, we do not create an object of the class containing the main() method. So. we have to make sure that the main() method can be accessed without creating an object of the main class. Hence, the main() method is static because the static methods belong to the class and not to a particular object.

For N = z

*

**

***

****

*****

Let us observe the pattern carefully. We can see that in the 1st row, there is only 1 star and in the second row, there are 2 stars. and so on. This means that in the ith row, we are printing i number of stars. Following is the C++ program for the same.

C++ Program

# include <algorithm>
# include <iostream>
# include <vector>
using namespace std;
int main() {
   //your code goes here;
   int N;
   cin>>N;
   for(int i=1;i<=N;i++) {
       for(int j=1;j<=i;j++) {
           cout<<"*";
       }
       cout<<"\n";
   }
}

Sample Input : 7

C++ is a compiled language, while Java is an interpreted language.

C++ supports pointers, while Java does not. C++ follows a procedural programming approach. while Java follows an object-oriented approach.

def fibonacci(n):
    fib_series = [0,1]
    while fib_series[-1] + fib_series[-2] <= n:
        fib_series.append(fib_series[-1] + fib_series[-2])
        return fib_series
n = int(input("Enter the number: "))
print("Fibonacci series up to", n, ":", fibonacci(n))

def reverse_string(s):
    reversed_str =""
    for i in range(len(s) - 1, -1, -1):
        reversed_str += s[i]
        return reversed_str
    
input_str = input("Enter a string: ")
print(" Reversed string:", reverse_string(input_str))

def factorial(n):i
    if n == 0 or n == 1:
        return 1
    else:
        return n * factorial(n - 1)
num = int(input("Enter a number: "))
print("Factorial of", num, "is", factorial(num))

The "static" keyword is used to declare variables, methods, and blocks that belong to classes rather than any specific instance. Static members can be accessed without creating an object of the class.

def binary_to_decimal( binary):
    decimal = 0
    power = 0
    for digit in reversed(binary):
        decimal += int(digit)*(2** power)
        power += 1
        return decimal
binary_num = input("Enter a binary number:")
print("Decimal equivalent:", binary_to_decimal(binary_num))

The "final" keyword will restrict the modification of variables, methods, and

classes. A final variable cannot be reassigned, a final method cannot be overridden,

and a final class cannot be extended.

def rotate_array(arr, k):
    return arr[k:] + arr[:k]

array = [1,2,3,4,5]
k=2
print ("Original array:", array)
print("Array after rotation:", rotate array(array, k))

The "super" keyword is used to call the constructor or methods of the parent class from a subclass. It is also used to access the parent class members if they have been overridden in the subclass.

The pre-increment operator (++i) increments the variable's value and then returns the incremented value, the post-increment operator (i++) returns the current value of the variable and then increments it.

def bubble_sort(arr):
    n = len(arr)
    for i in range(n - 1):
        for j in range(0, n-i-1):
            if arr[j] > arr[j +1]:
                arr[j], arr[j + 1] = arr[j + 1], arr[j]
    
array = (64, 34, 23,12, 22,11,90)
print("Original array:", array)
bubble_sort( array)
print("Sorted array:", array)

An abstract class is a class that cannot be instantiated and may contain abstract methods (methods without a body) that its subclasses must implement. A concrete class is a class that can be instantiated and contains implementation for all of its methods.

A "static" block in Java code, executed when the class is loaded into memory by the JVM. It will be to initialize static variables or perform another one-time initialization task.

"String" class -Java is immutable, meaning its value cannot be changed once created. The "StringBuilder" class is mutable and provides a more efficient way to modify and manipulate strings.

The "instance of" operator in Java is used to check whether an object is an instance of a particular class or an instance of a subclass of that class. It is commonly used for type-checking and casting objects.

The "package" in Java to organize and group related classes and interfaces into a namespace. It helps to prevent naming conflicts and provides a way to control access to classes and interfaces.

A "HashSet" is an unordered collection of unique elements, while a "LinkedHashSet" is an ordered collection of unique elements that maintains the insertion order of elements.

The "switch" statement in Java is a control flow statement that evaluates an expression and executes the associated block of code based on the value of the expression. It provides a more concise and readable alternative to nested "if-else" statements.

The "try-with-resources" statement in Java is used to automatically close resources (e.g., files, database connections, etc.) that implement the AutoCloseable interface. It ensures that these resources are properly closed, even in the event of an exception, eliminating the need for explicit closing in a "finally" block.

In Java, "fail-fast" iterators throw a ConcurrentModificationException if the collection is modified while iterating over it. This behavior is designed to prevent unexpected behaviors and maintain the integrity of the data.

On the other hand, "fail-safe" iterators create a copy of the collection and iterate over that copy, allowing modifications to the original collection without causing exceptions. However, the iterator may not reflect the changes made to the original collection. The Iterator interface in Java implements the "fail-fast" behavior, while the ConcurrentHashMap.KeySetView and ConcurrentHashMap.Values classes provide "fail-safe" iterators.