PwC Interview Questions

PwC Pvt Ltd has a thorough procedure for its recruitment process. In the PwC recruitment process, they assess the candidate's technical knowledge as well as analytical ability. Interview rounds can be different based on the role type in PwC.

Before going into the PwC hiring process, let us see the eligibility criteria.

Eligibility for Freshers: 

• Should not have any active backlogs or arrears.
• Should have 60+ % or 6+ GCPA throughout the education career. (subject to company policy and it may change).

For this role, They have majorly 4 rounds:

1. Aptitude Round
2. Technical Round
3. Partner Round
4. HR Round

1. Aptitude Round: This round is an online round conducted by PwC and usually contains 3 sections to access the candidate. These sections are

• Verbal Ability: This section assesses the candidate's ability in the English language. Questions in this section generally include filling in the blanks with the correct tense, filling in the blanks with the correct preposition, choosing the correct synonym and correct antonym, and so on. It can also include paragraph based questions wherein a passage will be given and you need to answer 3 to 4 questions based on that passage.
• Numerical Ability: This section assesses the candidate's ability in Mathematics. Questions in this section generally include questions on math problems like Speed & Distance, Profit & Loss, Permutations & Combinations, Probability, Clocks, Simple & Compound Interest, etc. 
• Reasoning Ability: This section assesses the candidate’s logical reasoning. Questions in this section generally involve finding the next term of a given series, matching the pattern, finding the odd one out, and so on.

Note: Generally there will be no coding questions in this round. 

2. Technical Round: Based on the performance of the Aptitude Round, Candidates will have a technical round. Even for a technology consultant role, there are many different profiles like SAP, Microsoft ERP, Oracle ERP, Data Analytics, CyberSecurity, etc. This technical round focuses on the technical aspects of the corresponding profile as well as the general technical concepts. There will be a thorough resume review by the interviewers who can ask questions on your previous projects & technologies mentioned in the resume. Doing a thorough review of your resume will be very helpful before appearing for this round. Apart from these things, there can be questions on fundamentals of Computer Science fundamentals like Object Oriented Programming Concepts (OOPs), Database Management Systems (DBMS), Computer Networks (CN), Operating Systems (OS), Computer Organization and Architecture (CoA), etc. The candidate should have experience in at least one of the programming languages like C, C++, Java or Python based on the profile. Even though it is a technical round, the interviewers can ask non-technical questions/ HR questions.  Depending on the experience, there can be more than 1 technical round.

3. Partner Round: Based on the performance of the Technical Round, Candidates will be advanced to the Partner Round. This round will be taken by Executive Directors at PwC Pvt Ltd. The questions asked in this round can be either Technical based or HR based or both. They also assess whether a candidate can be a good fit for the culture of the company or not in this round.

4. HR Round: The final round will be the HR round. In this round, the questions will be majorly on your resume, past experiences, and general HR questions. This round also assesses whether the candidate is the right fit for the culture of the company. Make sure to read the purpose and values of PwC Pvt Ltd mentioned in the About PwC section & also visit the company's website to learn more about the company. Following are the list of most frequently asked questions in an HR Interview:

• Walk me through your resume
• Why PwC Pvt Ltd?
• Why consultant role? Why not direct IT companies?
• Would you consider relocating to another part of India?
• Where do you see yourself in 5 years/ 10 years?
• Tell me about a difficult situation that you had to deal with?
• What are your long term goals?
• What do you think are your strengths and weaknesses?

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.

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

Employee table:

To find the maximum salary,

SELECT MAX(Salary) from Employee; // To just get the max salary
SELECT * from Employee where Salary = (SELECT MAX(Salary) from Employee); // Employees with highest salary

To find the average salary,

SELECT AVG(Salary) from Employee;

To find the minimum salary,

SELECT MIN(Salary) from Employee; // To just get the min salary
SELECT * from Employee where Salary = (SELECT MIN(Salary) from Employee); // Employees with lowest salary

Useful Interview Resources

• 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.

import sys

list_elements = [1,1,1,1,1,1]
tuple_elements = (1,1,1,1,1,1)

print('List memory took: ' + str(sys.getsizeof(list_elements)) + ' bytes')
print('Tuple memory took: ' + str(sys.getsizeof(tuple_elements)) + ' bytes')

# Output
# List memory took: 104 bytes
# Tuple memory took: 88 bytes

• 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.

nums = list(range(1, 21)) # Include 20
filtered_elements = list(filter(lambda x: (x%2 == 0), nums)) # convert iterator to list

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.

#include<iostream>

void printVal(int i)
{
   if(i > 100)
       return;
   std::cout<<i<<"\n";
   printVal(++i);
}

int main() {
  
   int i = 1;
   printVal(i);
}

int main() {
   for(;;)
   std::cout<<"hello\n";
}

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.

for(;;) // This is fine because condition is replaced by nonzero-constant by compiler as per the specification of C++ language

while() // This gives an error as it doesn't have condition expression

if() // This also gives an error as it doesn't have condition expression

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:

struct MyStruct
{
   int myInt;
   char myChar;
};

int main()
{
   MyStruct* firstPtr = new MyStruct();
  
   // .... some code here
  
   MyStruct* secondPtr = firstPtr;
   secondPtr->myInt = 5;
   secondPtr->myChar = 'A';
   delete secondPtr;

   // ... some code here

   std::cout<<firstPtr->myInt<<" "<<firstPtr->myChar<<"\n";
}

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, 

int run = 1;

while(run)
{
   // Do something and don't involve run variable at all
}

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: 

#include<iostream>
#include<string>
#include<algorithm>

using namespace std;

// To reverse a string
string reverseString(string str)
{
   int len = str.length();
  
   int mid = len / 2;
   // Traverse until mid and swap characters from ends
   for (int i = 0; i < mid; i++)
       swap(str[i], str[len - i - 1]);
  
   return str;
}

bool isPalindrome(string a)
{
   // This reverse the string
   string b = reverseString(a);

   // Check if reversed string and original string are same
   return a == b;
}

int main()
{
   string s1 = "BANANA";
   string s2 = "MADAM";
  
   cout<<s1<<" is "<< (isPalindrome(s1) ? "NOT ": "") <<" a PALINDROME\n";

   cout<<s2<<" is "<< (isPalindrome(s2) ? "NOT ": "") <<" a PALINDROME\n";
}

Output:

BANANA is NOT  a PALINDROME
MADAM is  a PALINDROME

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.

#include<iostream>
#include<string>
#include<algorithm>

using namespace std;

bool isPalindrome(string a)
{
   int len = a.length();

   int start = 0;
   int end = len-1;
  
   while(start < end)
   {
       // if not same then return false
       if(a[start] != a[end])
       {
           return false;
       }

       // update the start and end
       start++;
       end--;
   }

   // If it had reached upto this, then all characters are equal until mid
   return true;

}

int main()
{
   string s1 = "BANANA";
   string s2 = "MADAM";
  
   cout<<s1<<" is "<< (isPalindrome(s1) ? "NOT ": "") <<" a PALINDROME\n";

   cout<<s2<<" is "<< (isPalindrome(s2) ? "NOT ": "") <<" a PALINDROME\n";
}

Output:

BANANA is NOT  a PALINDROME
MADAM is  a PALINDROME

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.

• Role Understanding: Understand the role for which you are applying. Gather as much information as you can about the job position you're applying for, such as the skill set required, educational requirements, and so on. As there are different types of roles in PwC and also different profiles per role, have an understanding of the role and profile that you are going to get interviewed for.
• Resume Projects: Go through each and every detail mentioned in the resume and be thorough about the mentioned projects and technologies. Don't include projects or technologies that you are not aware of. Refresh the memory on the past projects included in the resume also on the technologies mentioned.
• Practice DSA: Make it a practice to solve Data Structure and Algorithm problems on a regular basis. You can visit the programming section of our site through this link. We have curated the list of frequently asked DSA questions for each company topic wise. Solving them will give you an edge in interviews. Also, go through the PWC interview experiences. This will give you an idea of how an actual interview takes place.
• Never Give Up: Never give up easily on the problems asked in the interview. If you can't think of any solution immediately, then try to solve it using a brute force approach and then do optimizations on top of it to eventually get to the optimal solutions. Always think from different perspectives and keep hitting it from different sides.
• Grab Hints: Take note of the hints. If you get stuck, interviewers are always willing to help and will give you specific advice. It's critical to grab the hint as soon as possible and go on to the next step. It's a significant red flag if you can't figure out what the hint is.
• Behave Professionally: Keep in mind that interviewers are not only judging whether you have sufficient skills or not. They are also judging your interpersonal skills like how you behave when a difficult question is asked, how you think through that question, whether you can be a great fit for the culture of the company, whether you are interrupting the interviewer, or not etc. So think twice before talking and don't raise any red flags.
• Think Loud: Learn how to "think aloud." It's strange, but in an interview environment, demonstrating how you arrived at a solution or explaining why you're doing X before Y is the most crucial aspect.
• Research & Communication: The HR interviewer will be generally quite friendly, so there’s no need for you to get anxious. Be cool while answering questions asked in the HR round, because they are not going to check your technical skill. HR round will not sound difficult if you have good communication skills. But the candidates have to come well prepared with answers for questions like self-introduction, strengths, and weaknesses, resume walkthrough etc. Also, learn about the purpose and the values of PwC Pvt Ltd. Whenever got a chance in the interview, use these terms to have a definitive advantage because this shows that you have researched about the company and your willingness to join the company.
• Mock Interviews: Give mock interviews a shot. This will give you an idea of what to expect during the actual interview. For mock interviews, you can use our InterviewBit platform. You'll be partnered with a peer, and the two of you will be able to conduct interviews with each other, making it a win-win situation for both of you.  The more mock interviews you give the more confidence you get and the more confidence you have the better you perform in the interview. This also helps in improving your communication skills.

This question needs to be answered very carefully. We should never say anything bad about the current company, manager and peers. Always drive the conversation to your career goals and how the role that you are applying for in PwC can help achieve it. In short, frame your move as a path to advancing your career without disparaging your current job. If you have heard positive reviews about PwC, then mention them as well.

There is no standard timeline on how long the Interview Process at PwC is going to take. It all depends on the position, location, urgency etc. PwC usually doesn't prefer keeping the employees on the bench i.e., they usually don't hire excess candidates and keep them on the bench. So even if you successfully passed all interviews, it may take more than 10 days sometimes to get the final offer letter. Generally speaking, the Interview Process usually takes 1 week to 1 month.

• Should not have any active backlogs or arrears.
• Should have 60+ % or 6+ GCPA throughout the education career. (subject to company policy and it may change).
   

Nothing is hard if we have the right preparation and determination. These interviews majorly focus on resumes, coding problems (DSA & Algorithms), OOPs and fundamentals of computer science. Acquire good knowledge on these topics to fulfil the PwC career goal with flying colours.

There is no online coding round currently for PwC. But coding questions will be asked in the interview process.

PwC Pvt Ltd currently pays freshers a joining salary of Rs. 6.5 lakh per year on average. Usually, PwC software engineer salary is in the range of Rs. 6 lakh per year to Rs. 8.5 lakh per year for freshers.

Always talk about the values the company values and show that you also abide by those values. Talk about the recent news about the company/ products that you like about this company and show your desire to grow and learn while working for this company. Honestly talk about what you like about the company (not the compensation 😉) and why you want to work for this company.