Commonly Asked Wipro Interview Questions and Information on Wipro Recruitment for 2023 - IQCode

About Wipro

Wipro Limited is a prominent global firm that provides information technology, consulting, and business process services (NYSE: WIT, BSE: 507685, NSE: WIPRO). Wipro uses advanced technologies like cognitive computing, hyper-automation, robots, cloud, and analytics to help its clients successfully adapt to the digital environment. With over 200,000 committed employees, Wipro services clients across six continents and is known globally for its broad range of services, strong commitment to sustainability, and excellent corporate citizenship. Wipro is constantly looking for new ideas to create a better and more sustainable future.

Working at Wipro is a fantastic opportunity to realize your full potential, progress consistently, and work alongside some of the brightest minds in the industry with cutting-edge technology. Wipro is an exciting workplace with ongoing innovation, a fair play culture, and a great working environment. Wipro empowers each employee to create their own career path, which distinguishes it as an organization with no boundaries. Wipro believes that people and their innovative expertise are the only ways to achieve company efficiency.

Wipro could be the right place for you if you have the passion, talent, and ability to work with cutting-edge technology. Please read the eligibility requirements below.

Eligibility Criteria:

- Candidates with a B.E./B.Tech degree or a 5-year integrated M.Tech degree are eligible. - All branches except Fashion Technology, Textile Engineering, Agriculture, and Food Technology are permitted to participate in the recruitment process. - The offer is conditional on clearing all backlogs. - A maximum of three years of an educational gap will be permitted (10th to graduation). - 60 percent or higher in tenth and twelfth-grade. - Graduation: 60% or 6.0 CGPA or equivalent, as determined by your university's requirements.

Wipro Recruitment Process

Wipro's interview process includes the following steps:

1. Online Assessment Test 2. Technical & HR Interview

Note: Shortlisted candidates will receive an email with additional information on the online test's date, time, and other procedure-related information.

Code: N/A

Plain text: To apply for a job at Wipro, one must meet the above eligibility criteria. After which, the interview process involves an Online Assessment Test and a Technical & HR Interview. The shortlisted candidates will receive an email with all the relevant details.

Wipro Technical Interview Questions for Freshers and Experienced

Q: What is the reason behind macros being faster than functions in the C programming language?

In C programming language, macros are generally faster than functions due to the absence of function call overhead. Macros are preprocessed and substituted directly into the code, while functions require a function call that adds some additional execution time. Another reason for macros being faster is that they avoid the overhead of parameter passing, stack manipulation, and return value copying. However, macros may have some disadvantages over functions such as the lack of type checking and multiple evaluations of arguments. Therefore, it's important to use macros carefully, checking for any possible issues that may arise.

Differences between Object-Oriented and Object-Based Programming Languages

Object-oriented programming languages (OOPL) and object-based programming languages (OBPL) are two types of programming paradigms that differ in their approach to utilizing objects.

In an OOPL, everything is an object, and classes define the functions, properties, and behavior of each object. The primary focus is on the objects themselves, and each object has its own unique behavior.

In contrast, an OBPL does not have the concept of classes. Instead, it uses pre-defined objects and allows the creation of new objects by copying existing ones. The objects in OBPL are not as independent as they are in OOPL and often rely on each other to function correctly.

Another key difference is inheritance, which is a fundamental concept in OOPL but doesn't exist in OBPL. Inheritance allows a class to inherit properties and behavior from another class, creating a hierarchy of objects and classes.

Overall, OOPLs provide more flexibility, modularity, and scalability than OBPLs, making them more suitable for complex programming tasks. However, OBPLs are easier to use and understand, making them a good choice for simpler applications.

Understanding Order of Precedence and Associativity in Java

In Java, operators have a specific precedence level that determines the order in which they are executed. The order of precedence can be thought of as a hierarchy, where some operators are evaluated before others. For example, multiplication and division have a higher precedence than addition and subtraction.

Additionally, some operators have the same precedence level. In this case, the associativity of the operators determines the order in which they are evaluated. Associativity can be either left-to-right or right-to-left.

To use order of precedence and associativity correctly in Java, it's important to understand the rules and hierarchy of operators. It's also important to use parentheses to explicitly indicate the order of operations when needed. This can prevent errors and ensure that expressions are evaluated correctly.

Requesting Garbage Collection in Java

In Java, you can request garbage collection using the `System.gc()` method. It suggests the JVM to start the garbage collection process. However, this is only a request and the JVM may not immediately run the garbage collector.

If you want to force the garbage collection process, you can use the `Runtime.getRuntime().gc()` method. This method provides a hint to the JVM to run the garbage collector immediately.

It is important to note that manually forcing garbage collection is usually not necessary as the JVM automatically runs the garbage collector when it detects a low memory situation.

Aggregation vs Composition in Java

In Java, aggregation and composition are two different concepts used to represent the relationship between objects.

Aggregation is a relationship between two objects where one object can exist independently of the other object. It means that the child object can exist on its own, without the parent object. In Java, aggregation is implemented using references or pointers. For example, a car object can have a reference to a driver object. The driver can exist independently of the car.

Composition, on the other hand, is a relationship between two objects where one object is composed of the other object. In other words, the child object cannot exist independently of the parent object. If the parent object is destroyed, the child object is also destroyed. In Java, composition is implemented using instance variables or member variables. For example, a house object can have instances of rooms, and if the house is destroyed, all the rooms are also destroyed.

To summarize, the key difference between aggregation and composition is that in composition, the existence of the child object depends on the existence of the parent object, while in aggregation, the child object can exist independently of the parent object.

Differences between Error and Exception in Java

In Java, both Error and Exception are classes that represent abnormal conditions that can occur during the execution of a program. However, there are differences between these two classes.

  • Errors are typically caused by the JVM and indicate serious problems that cannot be handled by the application. Examples include OutOfMemoryError and StackOverflowError.
  • Exceptions are typically caused by problems in the application code and can often be handled programmatically. Examples include NullPointerException and IOException.
  • Errors are unchecked, meaning that the programmer is not required to handle them explicitly. In contrast, exceptions are checked, meaning that the programmer is required to handle them or declare that they are thrown.
  • Errors are generally irrecoverable and should not be caught, whereas exceptions can often be recovered from by catching and handling them appropriately.

In summary, errors and exceptions are both types of abnormal conditions that can occur during Java program execution, but errors are more serious and generally cannot be handled, while exceptions can be handled and recovered from if properly handled.

Difference between Strings and Char Arrays in Java

In Java, a String is an object that represents a sequence of characters, whereas a char array is a data structure that contains a sequence of characters.

Here are some key differences between Strings and Char Arrays:

  • Strings are immutable, which means that their values cannot be changed once they are created. Char arrays, on the other hand, are mutable and their values can be changed.
  • String class provides many methods to manipulate and work with strings, whereas char arrays have limited built-in functionality.
  • String is a class in Java and we can create an object of String using the new keyword. Whereas, char arrays are native to Java so we can create them directly without using the new keyword.
  • String class overrides equals() and hashCode() methods, whereas char arrays use reference equality for equals() and hashCode() methods.

In general, Strings are more convenient to work with when we need to pass them to APIs or functions that take Strings as parameters. Char arrays are more efficient when it comes to memory usage and when we need to manipulate individual characters.

Preconditions and Postconditions in C++ Member Functions

In C++, preconditions refer to the requirements that must be met before a member function can be executed properly. These preconditions may include, for example, that a certain variable has a specific value, or that an object has been initialized properly.

Postconditions, on the other hand, refer to the state of the object and program after the member function has executed successfully. Postconditions may include changes in the value of a variable or object, or certain output produced by the function.

It is important for a programmer to document both preconditions and postconditions in the comments of a member function to ensure proper understanding and usage by other programmers. By following these guidelines, you can create more robust and reliable C++ programs.

Understanding Stack Unwinding in C++

In C++, the stack is used for function calls and local variable storage. Stack unwinding is the process of deallocating memory from the stack when a function exits. This is important for memory management and preventing memory leaks.

During stack unwinding, destructors for objects on the stack are called in reverse order of their creation. If an exception occurs, the stack is unwound until the matching catch block is found. If no catch block is found, the program terminates abnormally.

To handle exceptions and prevent abnormal termination, it is important to properly manage the stack and use try-catch blocks to catch exceptions and handle them appropriately. Proper use of try-catch blocks can ensure the safety and stability of a C++ program.

Explanation of free() and delete() in C++

In C++, free() and delete() are used to deallocate memory allocated dynamically through functions like malloc(), calloc(), and new operator. Both perform similar tasks but in different ways.

free() is a function from the C language and is used to deallocate memory that was allocated using functions like malloc() and calloc(). It takes a pointer to the allocated memory as an argument and frees it. When you use free(), the memory block is deallocated, but the pointer still points to the same memory location. Accessing the memory location after deallocation using free()leads to undefined behavior.

delete() is an operator in C++ and is used to deallocate memory that was allocated using new operator. It also invokes the destructor before deallocating memory. When you use delete(), the memory block is deallocated, and the pointer is set to NULL. Accessing the memory location after deallocation using delete() is not possible, and doing so will result in a runtime error.

It is important to use the correct deallocation function to avoid memory leaks and undefined behavior in your C++ code.

Copy Constructor vs Assignment Operator in C++

In C++, a copy constructor is a special member function that is called when a new object is created from an existing object. It is used to create a new object that is a copy of an existing object. On the other hand, an assignment operator is also a special member function that is used to assign an existing object to a newly created object.

The fundamental difference between these two is that a copy constructor is used when a new object is created, while the assignment operator is used when an existing object is being assigned a new value. Another difference is that the copy constructor takes a reference to the object it is copying, while the assignment operator takes a reference to the object being assigned.

It is important to note that if a class does not define its own copy constructor or assignment operator, the compiler generates them automatically. However, if a class has pointers or dynamically allocated memory, it is best to define these functions explicitly to ensure proper memory management.

Here is an example of a copy constructor and assignment operator for a class called "Person":

class Person {
    string name;
    int age;
    Person(string n, int a) : name(n), age(a) {}

    // Copy constructor
    Person(const Person& p) {
        name =;
        age = p.age;

    // Assignment operator
    Person& operator=(const Person& p) {
        if (this != &p) {
            name =;
            age = p.age;
        return *this;

In summary, both the copy constructor and assignment operator are important functions in C++, used to create and assign values to objects. Understanding the difference between the two is crucial in proper memory management and class design.

Code: Finding LCM of an Array of Numbers

The following code takes an array of integers as input and returns the least common multiple (LCM) of those numbers.

public class LCMCalculator {
    * Method to calculate the GCD of two numbers
    public static int getGCD(int num1, int num2) {
        if (num2 == 0) {
            return num1;
        return getGCD(num2, num1 % num2);
    * Method to calculate the LCM of an array of numbers using the getGCD method
    public static int getLCM(int[] nums) {
        int lcm = nums[0];
        for (int i = 1; i < nums.length; i++) {
            lcm = (lcm * nums[i]) / getGCD(lcm, nums[i]);
        return lcm;
    * Main method to test the getLCM method
    public static void main(String[] args) {
        int[] nums = {2, 4, 6, 8};
        int lcm = getLCM(nums);
        System.out.println("LCM of the given array of numbers: " + lcm);

The getGCD method calculates the greatest common divisor (GCD) of two numbers which is used by the getLCM method to calculate the LCM of an array of integers. The getLCM method takes an array of integers as input and iterates through each integer in the array. For each iteration, it calculates the LCM of the current integer and the previously calculated LCM using the GCD of the numbers. Finally, it returns the LCM of the entire array. The main method in this code is used to test the getLCM method by passing a sample array of integers.

Get the Nth Fibonacci Number in O(N) Time and O(1) Space Complexity

Write a function that takes a positive integer 'n' as input and returns the nth Fibonacci number. The Fibonacci sequence is a series of numbers in which each number is the sum of the two preceding numbers. The sequence starts with 0, 1, 1, 2, 3, 5, 8, 13, 21, and so on.

To solve this problem, we can use a loop and keep track of the two previous Fibonacci numbers. We start with the first two numbers of the sequence, 0 and 1, and then iterate through the loop until we reach the nth Fibonacci number.

function getNthFibonacciNumber(n) {
  let previousNum1 = 0;
  let previousNum2 = 1;
  let currentNum;

  if (n === 0) {
    return 0;
  } else if (n === 1) {
    return 1;

  for (let i = 2; i <= n; i++) {
    currentNum = previousNum1 + previousNum2;
    previousNum1 = previousNum2;
    previousNum2 = currentNum;

  return currentNum;

In the above code, we first define the initial values of the two previous Fibonacci numbers and the current number. Then, we check if the input n is 0 or 1, and return the corresponding Fibonacci number in those cases. If n is greater than 1, we use a for loop to iterate through the sequence and calculate each Fibonacci number until we reach the nth one.

Important Functionalities/Features of an Operating System

An operating system (OS) serves as a vital part of any computer system as it manages hardware resources and provides essential services to software applications. Here are some of the critical functionalities/features that an operating system must-have:

1. Process and Memory Management - The OS must allow efficient management of processes and memory by allocating and deallocating memory space, managing system resources, and facilitating process synchronization and inter-process communication.

2. File System Management - An OS must provide an efficient and secure file system that can manage files and directories, ensure data integrity, and maintain data confidentiality.

3. Device Management - Operating systems must manage and communicate with various hardware devices such as keyboards, printers, and storage devices.

4. Security and Protection - The OS must provide a secure environment by implementing user authentication, encryption, and virus protection mechanisms.

5. Networking and Communication - An OS must support network protocols and provide essential networking services like TCP/IP to enable communication between different devices.

6. System Utilities - OS provides various system utilities, tools, and diagnostic functions to help users monitor and troubleshoot problems.

7. User Interface - Operating systems must provide an easy-to-use and intuitive user interface, making it easy for users to interact with the system and applications.

Advantages and Disadvantages of Time Slicing in CPU Scheduling in OS

Time slicing is a technique used by Operating Systems (OS) to allocate CPU time to multiple processes. The CPU takes turns switching between these processes for a short duration of time. The advantages and disadvantages of this technique are as follows:


  • Time slicing ensures that each process gets an equal share of the CPU time, preventing any process from hogging the entire CPU and starving others of resources.
  • Processes can be given equal priority, allowing for seamless multitasking.
  • Time slicing can minimize the response time of an operating system when multiple processes are running.
  • It can improve system utilization since the CPU is used optimally by allowing multiple processes to run concurrently.


  • Time slicing can cause overhead due to frequent context switching between different processes, which can slow things down.
  • The technique can also cause system instability or inconsistency due to processes being temporarily suspended mid-execution.
  • The accuracy of time slicing is entirely dependent on the clock resolution, so there could be some fairness issues when multiple processes finish within the same time slice.
  • Some processes may not be suited for time slicing because they may have real-time requirements or be sensitive to the length of time that they can run.

Overall, time slicing is a widely used and effective technique for CPU scheduling in OS, but it comes with its trade-offs.

Types of Shells in Linux

In Linux, there are several types of shells available, each with different features and capabilities. The most commonly used shells are:

  • Bash (Bourne-Again SHell)
  • Zsh (Z SHell)
  • Ksh (Korn SHell)
  • Csh (C SHell)
  • Tcsh (TENEX C SHell)

Each shell has its own set of features and advantages, so choosing the right shell is important based on your needs and requirements.

Advantages and Disadvantages of Indexing in DBMS

When it comes to managing large amounts of data in a database, indexing can be a useful tool to improve query performance. However, there are both advantages and disadvantages to using indexing in a database management system (DBMS).


- Improved query performance: Indexing can significantly improve the speed of data retrieval from a database, by reducing the amount of disk I/O required to access relevant data. - Faster sorting: Indexing can also make sorting faster, by allowing the DBMS to quickly locate and retrieve the relevant data. - Efficient updates: With proper indexing, updates to the database can be done more efficiently, by avoiding the need to rebuild large portions of the data.


- Increased storage: Indexing requires additional storage space to maintain index structures, which can lead to increased storage requirements for the database. - Overhead: Creating and maintaining indexes can be a resource-intensive operation, especially when dealing with large databases. - Potential performance degradation: Poorly-designed or overused indexes can actually decrease query performance, by creating additional overhead without providing significant benefit.

In summary, indexing can be a powerful tool for improving query performance and data management in a DBMS, but it should be used judiciously, with careful consideration given to its potential impact on storage requirements and system performance.

Explanation of the Differences Among SQL Commands DROP, TRUNCATE, and DELETE

In SQL, there are three commands commonly used for removing data from a table, including DROP, TRUNCATE, and DELETE. Although their purpose might seem the same, there are significant differences among them.

DROP Command: This command is used to remove an entire table including all its data permanently. If a table is removed with the DROP command, it cannot be undone and there is no way to rollback the changes.

TRUNCATE Command: This command is also used to remove data from a table, but it only removes the rows and deallocates the data pages of the object. The TRUNCATE command is quicker and less resource-intensive than the DELETE command, but it cannot be used to delete selected rows based on conditions.

DELETE Command: This command removes specific records from a table based on certain conditions. The DELETE command can be used with or without the WHERE clause to specify which rows to delete from the table. Unlike the TRUNCATE command, the DELETE command is slower and more resource-intensive. Additionally, it can be rolled back if the transaction is not yet committed.

In summary, while these three commands can all remove data from a table, they serve different purposes and have varying effects. It's essential to choose the right command for the task at hand to avoid unintended consequences.

Understanding SQL Profiler

SQL Profiler is a tool for Microsoft SQL Server that captures and records SQL Server events. It allows users to monitor different activities occurring within SQL Server, including queries, connections, stored procedures, and database backups. SQL Profiler is often utilized for performance tuning, troubleshooting, and auditing purposes. By collecting and analyzing data about SQL Server events, SQL Profiler can help identify and address issues that could impact server performance, security, and reliability.

Benefits of Hybrid Clouds in Cloud Computing

Hybrid clouds offer several advantages in cloud computing. Firstly, they allow organizations to maintain sensitive data on-premises while taking advantage of the flexibility and scalability of the public cloud for less sensitive data. This enables organizations to keep their critical information secure and ensures compliance with data privacy laws.

Secondly, hybrid clouds provide the ability to scale up or down quickly based on business needs. By utilizing the public cloud for peak workloads, organizations can take advantage of the on-demand resources and then scale back down to their on-premises infrastructure when the demand normalizes.

Thirdly, hybrid clouds enable organizations to take advantage of cost savings associated with the public cloud, without completely abandoning their investment in on-premises infrastructure. This helps to minimize the risks associated with the transition to the cloud.

Lastly, hybrid clouds can improve disaster recovery capabilities by providing redundancy across on-premises and public cloud infrastructures. In the event that one infrastructure fails, the other can take over seamlessly, preventing data loss and minimizing downtime.

Overview of Eucalyptus in Cloud Computing and Its Functionalities

Eucalyptus ( Elastic Utility Computing Architecture for Linking Your Programs To Useful Systems) is an open-source software for building private, public and hybrid clouds. It provides a scalable, secure and flexible computing environment for deploying and managing cloud applications.

Some of the key functionalities of Eucalyptus in cloud computing include:

1. Elastic Computing: Eucalyptus allows users to dynamically provision and de-provision computing resources on demand, ensuring optimal utilization of resources.

2. Multi-Tenancy Support: Eucalyptus provides secure and isolated environments for multiple users on a shared infrastructure, allowing each user to have their own virtual resources.

3. Hybrid Cloud: Eucalyptus enables users to build hybrid clouds by seamlessly integrating with public cloud services like AWS, providing a consistent management interface for all cloud resources.

4. Compliance and Security: Eucalyptus provides strong security features, including encryption, user authentication and access controls, ensuring data privacy and compliance with regulatory standards.

5. Flexible Networking: Eucalyptus allows users to define their own network topologies and configure virtual networks as needed, providing a flexible and customizable networking environment.

In summary, Eucalyptus is a powerful cloud computing platform that provides a range of functionalities for building and managing private, public and hybrid clouds, making it an ideal choice for enterprises looking to leverage the benefits of cloud computing.

Explanation of the Project Management Life Cycle Method in the context of Project Management

The Project Management Life Cycle (PMLC) is a process used in project management to define, plan, execute, and close a project. It is a structured approach that helps organizations to manage their projects effectively and efficiently. The PMLC method aims to manage the project from beginning to end, ensuring that projects are delivered on time, within budget, and meet the project goals.

The PMLC consists of five phases, which include initiation, planning, execution, monitoring and controlling, and project closure. Each phase has a specific set of activities that must be completed before moving to the next phase.

In the initiation phase, the project management team defines the scope of the project, identifies project objectives and goals, and determines the project stakeholders. This is an important phase as it lays the foundation for the entire project.

The planning phase involves developing a project plan, which includes defining project activities, milestones, and deliverables, developing a budget, and assigning responsibilities. In this phase, the project manager also identifies risks and develops a risk management plan.

The execution phase involves implementing the project plan, monitoring project progress, and managing project resources. The project team works together to complete project activities, and the project manager oversees the project to ensure it is completed on time and within budget.

The monitoring and controlling phase involves tracking project performance, identifying issues, and making changes to the project plan to keep the project on track. The project manager monitors project progress and takes corrective action if necessary.

Finally, the project closure phase involves delivering the final product, releasing project resources, and conducting a post-project review to identify lessons learned.

In conclusion, the PMLC method is an effective approach to manage projects. Understanding and following the PMLC method help project managers and their teams to successfully complete projects on time, within budget, and meet project goals.

Understanding RAID in the Context of Project Management

In project management, RAID stands for Risks, Assumptions, Issues, and Dependencies. It is a tool used to manage and track potential risks and issues that may arise during the course of a project.

Risks refer to potential events or situations that may impact the project's success, while assumptions are things that are taken for granted but not necessarily proven to be true. Issues are problems that have already occurred and need to be addressed, and dependencies are tasks or actions that are reliant on the completion of other tasks or actions.

By tracking RAID items, project managers can proactively identify and manage potential obstacles to project success. This allows them to take preventative action to mitigate risks and address issues as they arise. Additionally, monitoring dependencies ensures that tasks are completed in the correct order, reducing the likelihood of delays to the project schedule.

Explanation of Difference between Block-level Elements and Inline Elements in HTML

In HTML, block-level elements and inline elements are used to structure and organize content on a web page.

Block-level elements are elements that take up the full available width of their parent container, creating a new line after the element. These elements are typically used for larger pieces of content such as paragraphs, headings, and dividers. Examples of block-level elements include




, and

On the other hand, inline elements only take up as much width as their content requires and can be placed within a block-level element. These elements are used for smaller pieces of content such as text or images. Examples of inline elements include , , and .

One key difference between these two types of elements is that block-level elements can have margin, padding, and width set, whereas inline elements cannot.

Therefore, understanding the difference between these two types of elements is important for proper HTML structuring and styling.

Main Differences between localStorage and sessionStorage Objects in HTML

The localStorage and sessionStorage objects are both used to store data in the client's browser, but they have some key differences:

  • Stores data with no expiration date.
  • Stored data is available even after the browser is closed and reopened.
  • Stored data can be accessed by any window with the same origin.
  • Stores data for one session only (data is lost when the browser tab is closed).
  • Stored data is not available after the browser is closed and reopened.
  • Stored data can only be accessed by the window that created it.

Therefore, localStorage is best suited for persistently storing user preferences and login information, while sessionStorage is ideal for storing data temporarily during a user's session.

What is the Purpose of a CSS Preprocessor and When Should You Use It in a Project?

A CSS preprocessor is a scripting language that extends the capabilities of CSS. It allows developers to simplify and optimize their CSS code by providing variables, functions, mixins, and nesting. The preprocessor then compiles the code into standard CSS, making it compatible with all browsers.

A preprocessor should be utilized in a project when there is a large and complex codebase that can benefit from the organizational and performance improvements that preprocessing provides. This is especially true for websites that require frequent updates or that have a team of multiple developers, as preprocessing can greatly enhance collaboration and code consistency.

Additionally, when implementing responsive design techniques, a preprocessor can be used to more easily manage breakpoints and media queries, saving time and reducing errors. Overall, a CSS preprocessor can greatly improve the efficiency and quality of a CSS codebase in larger projects.

Wipro Interview Preparation

Preparing for a job interview can be stressful, especially if it's for a company as big as Wipro. Here are some tips to help you ace your Wipro interview:

1. Research the Company

Be sure to research Wipro and learn about their values, mission statement, and products/services. This will help you answer questions about why you want to work for the company and what you know about them.

2. Brush Up Your Skills

Make sure you review the job description and practice skills that are relevant to the position. Be prepared to discuss your experience and how it relates to the job.

3. Dress Appropriately

Dressing professionally is important for any job interview. Make sure your clothes are clean, pressed, and fit properly.

4. Prepare Questions to Ask

At the end of the interview, the interviewer will likely ask if you have any questions. Prepare a list of questions ahead of time, such as asking about the company culture or growth opportunities.

5. Be Confident and Positive

Lastly, be confident and positive during the interview. Smile, make eye contact, and speak clearly. Remember, the interviewer is considering you for the job - show them that you're the best candidate for it.

Implement strStr()

In this problem, we are given two strings - haystack and needle. We need to find the index of the first occurrence of the needle in the haystack. If the needle is not present in the haystack, then return -1.

To solve this problem, we can use the two-pointer approach. We can loop through the haystack and check if the current character matches the first character of the needle. If it does, then we can compare the rest of the characters of the haystack and needle. If they match, we can return the index of the current character in the haystack. If there is no match, then we can increment the pointer for the haystack and continue the loop.

public class Solution {
    public int strStr(String haystack, String needle) {
        if (needle.isEmpty()) { // if needle is empty, return 0
            return 0;

        int hLen = haystack.length();
        int nLen = needle.length();

        for (int i = 0; i <= hLen - nLen; i++) { // loop through haystack
            if (haystack.charAt(i) == needle.charAt(0)) { // if current character matches first character of needle
                int j = 1;
                while (j < nLen && haystack.charAt(i+j) == needle.charAt(j)) { // compare remaining characters
                if (j == nLen) { // if all characters match, return index of current character in haystack
                    return i;

        return -1; // return -1 if needle not present in haystack

Multiple Left Rotations of an Array

Here is a problem related to arrays:

Given an array and multiple left rotations to be performed on the array, the task is to perform all the left rotations efficiently.

Let's solve this problem using code:

function getRotatedArray(arr, rotations) {
    const modRotations = rotations % arr.length; // get number of rotations
    return [...arr.slice(modRotations), ...arr.slice(0, modRotations)]; // create new array with the rotated elements

const array = [1, 2, 3, 4, 5];
const numRotations = 3;

const rotatedArray = getRotatedArray(array, numRotations); // [4, 5, 1, 2, 3]

In this code, we define a function called "getRotatedArray" that takes two parameters: "arr" (the array to rotate) and "rotations" (the number of left rotations to perform). We then use the "slice" method to get the elements of the array that need to be rotated and create a new array with those elements at the end. We then add the remaining elements from the beginning of the original array to the end of the new array. Finally, we return the new array with rotated elements.

After defining the function, we create an example array and specify the number of rotations to perform. We then call the "getRotatedArray" function with these values to obtain the rotated array.

String Inversion

Problem Statement:

Given a string, return another string with the same characters in reverse order.

public static String reverseString(String str) {
    String result = "";
    for(int i = str.length() - 1; i >= 0; i--) {
        result += str.charAt(i);
    return result;


Input: "hello"

Output: "olleh"

Sock Pair Problem

This problem involves finding the number of socks needed to make complete pairs.

    function sockPairs(socks) {
        let sockCounts = {};
        let count = 0;

        //count the number of socks of each type
        for (let i = 0; i < socks.length; i++) {
            if (sockCounts[socks[i]]) {
            } else {
                sockCounts[socks[i]] = 1;

        //count the number of pairs using the count of each sock type
        for (let sockType in sockCounts) {
            count += Math.floor(sockCounts[sockType] / 2);

        return count;

    //example usage
    let socks = ["red", "blue", "red", "green", "blue", "red"];
    let numPairs = sockPairs(socks);

In this example, the function counts the number of socks of each type and then determines the number of complete pairs that can be made using those counts.

Wipro Interview Questions

To access Wipro interview questions, please refer to the coding interview questions section.

Here, you will find a variety of interview questions that may be asked during the Wipro interview process.

Frequently Asked Questions

1. Is the Wipro interview easy?

//Answer: The level of difficulty of the Wipro interview varies from person to person and also depends on the specific job role. However, it is recommended that candidates prepare thoroughly and practice common interview questions to increase their chances of success.

How to Apply for Wipro Off Campus?

If you want to apply for Wipro Off-Campus recruitment, follow these steps:

1. Visit the Wipro careers website and register yourself.

2. Look for job openings and check if you meet the eligibility criteria.

3. If eligible, apply for the job by submitting your resume and other required documents.

4. If shortlisted, attend the recruitment process that may include an online test, technical interview, and HR interview.

5. If you clear all the rounds, you will be offered a job at Wipro.

Note: Make sure to keep your resume updated and highlight your skills and achievements to increase your chances of getting selected.

Discussing Strengths and Weaknesses

When it comes to strengths, I believe that my ability to communicate effectively with others is one of my strongest qualities. I am able to convey my thoughts and ideas clearly and confidently, which makes me an asset in team settings.

As for weaknesses, I have found that I can sometimes become overly critical of myself. While I believe in holding myself to high standards, I also need to remember to cut myself some slack when things don't go exactly as planned. To combat this tendency, I have been practicing mindfulness and self-compassion techniques to help me stay grounded and avoid becoming too self-critical.##

Reasons to Hire Me

In my opinion, I believe that I would be a valuable addition to this team for the following reasons:

1. Relevant Experience: I have several years of experience in the field that directly aligns with this position, which makes me confident in my ability to produce quality work efficiently.

2. Strong Work Ethic: I take pride in my work and am motivated to consistently produce excellent results. I am also highly organized and prioritize tasks effectively, which translates to increased productivity and successful project completion.

3. Adaptability: I am capable of adapting to new challenges and quickly learning new skills as needed. I am also comfortable working both independently and as part of a team, allowing me to contribute in various scenarios.

4. Passion for the Industry: I have a genuine passion for this industry and am excited to continue growing as a professional in this field. I am dedicated to staying up-to-date on industry trends and continually improving my skills and knowledge.

Overall, I believe that my experience, work ethic, adaptability, and passion for this industry make me a strong candidate for this position.


In the next five years, where do you envision yourself?

What is the Wipro Elite Test?

The Wipro Elite Test is a hiring test conducted by Wipro, an Indian multinational corporation that provides information technology, consulting, and business process services. The Elite Test is used to assess and select candidates for various positions within the company, including software engineers and business analysts. The test typically consists of multiple choice questions and may cover various topics related to computer science, mathematics, and logical reasoning. Passing the Wipro Elite Test is a crucial step towards getting hired by the company.

Technical Interview Guides

Here are guides for technical interviews, categorized from introductory to advanced levels.

View All

Best MCQ

As part of their written examination, numerous tech companies necessitate candidates to complete multiple-choice questions (MCQs) assessing their technical aptitude.

View MCQ's
Made with love
This website uses cookies to make IQCode work for you. By using this site, you agree to our cookie policy

Welcome Back!

Sign up to unlock all of IQCode features:
  • Test your skills and track progress
  • Engage in comprehensive interactive courses
  • Commit to daily skill-enhancing challenges
  • Solve practical, real-world issues
  • Share your insights and learnings
Create an account
Sign in
Recover lost password
Or log in with

Create a Free Account

Sign up to unlock all of IQCode features:
  • Test your skills and track progress
  • Engage in comprehensive interactive courses
  • Commit to daily skill-enhancing challenges
  • Solve practical, real-world issues
  • Share your insights and learnings
Create an account
Sign up
Or sign up with
By signing up, you agree to the Terms and Conditions and Privacy Policy. You also agree to receive product-related marketing emails from IQCode, which you can unsubscribe from at any time.