PwC Interview Questions For Freshers & Experienced Candidates (2024)

PwC has a properly laid out procedure for its recruitment process. In the recruitment process of PwC, the hiring managers judge the technical knowledge of the job candidate. They also check out the analytical ability of the job aspirants. The rounds of the interview can vary based on the type of role the job candidate is pursuing in PwC. Before finding out the intricate details of the PwC hiring process, let us check out the eligibility criteria for the job candidates.

Eligibility for Freshers

• The candidate should not have any arrears or active backlogs in the college examinations.
• The candidate should have a score of 60-plus% or 6-plus CGPA throughout the academic career (this cut-off is subject to change as per the company policy).

For almost all roles in PwC, the hiring team has designed a process of mainly 4 rounds:

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

Here's a table summarizing the differences between linear and non-linear data structures:

A palindrome is a word, phrase, number, or another sequence of characters that reads the same backward or forward. In other words, a palindrome remains unchanged when its letters or digits are reversed. For example, the words "radar", "level", "madam", and the number "12321" are palindromes, as they read the same from left to right as well as right to left.

          #include 
#include 
#include
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

In C programming language, volatile is a keyword that is used to indicate that a variable may change its value outside the control of the program. When a variable is declared as volatile, the compiler is informed that the value of the variable may change unexpectedly, and the compiler should not optimize or make any assumptions about the variable's value.

The volatile keyword is typically used in situations where the value of a variable can be changed by external factors that are beyond the control of the program, such as hardware interrupts, shared memory accessed by multiple threads or processes, or memory-mapped I/O registers. In such cases, the volatile keyword ensures that the compiler generates code that always reads the most up-to-date value of the variable from memory, and prevents any caching or optimization that may result in using stale or outdated values.

Here's an example of using the volatile keyword in C:

          volatile int flag = 0; // declare a volatile integer variable

// loop that waits for the flag to be set
while (flag == 0) {
// do something
}

// flag has been set, take appropriate action
      

In this example, the variable flag is declared as volatile to indicate that its value may change outside the control of the program, and the program should always read the most up-to-date value from memory when checking its value in the while loop. It's important to note that the volatile keyword only ensures that the compiler generates code that always reads the most up-to-date value from memory. It does not provide any synchronization or atomicity guarantees for concurrent access by multiple threads or processes. For concurrent access, additional synchronization mechanisms, such as mutexes or atomic operations, should be used in conjunction with volatile to ensure correct and thread-safe behavior.

Q7. What is a dangling pointer? How to handle it?

A dangling pointer is a pointer that points to a memory location that has been deallocated or freed, or a pointer that points to an object that has gone out of scope or has been deleted. Accessing or using a dangling pointer can lead to undefined behavior, as the memory it points to may no longer be valid or may have been allocated to a different object.

Dangling pointers commonly occur in C and C++ when memory is allocated dynamically using new or malloc, and then deallocated using delete or free, respectively, but the pointer to the memory is not set to nullptr or reassigned to a valid memory location after deallocation. Dangling pointers can also occur in C++ when a pointer to an object is accessed after the object has been deleted or has gone out of scope.

To handle dangling pointers, it's important to follow good memory management practices, including:

1. Always set pointers to nullptr or a valid memory location after deallocation to avoid accessing a dangling pointer.
2. Avoid using pointers to objects that have gone out of scope or have been deleted. Make sure that the pointer is still valid and points to a valid memory location before using it.
3. Use smart pointers or automated memory management techniques, such as RAII (Resource Acquisition Is Initialization) in C++, to automatically manage memory and avoid dangling pointers.
4. Be cautious with pointer arithmetic and avoid accessing memory beyond the allocated range.
5. Use tools like static analyzers, dynamic analyzers, and memory profiling tools to detect and fix dangling pointer issues in your code.

Handling dangling pointers requires careful attention to memory management practices and proper coding techniques to prevent accessing or using pointers that no longer point to valid memory locations.

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<myInt<<" "<myChar<<"\n";
}
        

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

The output for the code is -

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

The code provided contains an infinite loop that will continuously print the string "hello" followed by a newline character ("\n") to the standard output (usually the console or terminal) without any termination condition. This means that the loop will continue indefinitely, repeatedly printing "hello" to the output until the program is terminated externally, such as by manually stopping the program execution or encountering a runtime error.

As a result, if you were to run this code as-is, it would cause an infinite loop and repeatedly print "hello" to the standard output without end until you stop the program manually. It's important to be cautious when working with infinite loops as they can cause your program to hang or crash if not properly controlled or terminated.

Here's an example of how you can print the numbers from 1 to 100 in Python without using loops, using recursion:

          def print_numbers(n):
if n <= 100:
print(n)
print_numbers(n + 1)

print_numbers(1)
      

In this example, we define a recursive function print_numbers(n) that takes an argument n which represents the current number to be printed. The function first checks if n is less than or equal to 100, and if so, it prints the value of n and then calls itself with n + 1 as the argument. This recursive process continues until n reaches 100, printing all the numbers from 1 to 100 in the process. Note that recursion has its limitations, including potential stack overflow errors for large input values, so it's important to use it judiciously and with appropriate base cases to prevent infinite recursion. 

Bootstrap is a popular open-source front-end web development framework that provides a collection of pre-designed and pre-styled HTML, CSS, and JavaScript components for building responsive and modern web applications. It was originally developed by Twitter and is now maintained by the Bootstrap community.

Advantages of Bootstrap over CSS:

1. Rapid development: Bootstrap provides a set of ready-to-use UI components, such as buttons, forms, modals, carousels, and more, that can be easily incorporated into web pages. These components are pre-styled and responsive, which allows developers to create professional-looking websites quickly and efficiently, without having to write extensive CSS code from scratch.

2. Consistency and cross-browser compatibility: Bootstrap ensures consistent styling and appearance across different web browsers and devices. It has been thoroughly tested and is designed to work well in all modern browsers, including Chrome, Firefox, Safari, and Edge, as well as on different devices, such as desktop computers, tablets, and mobile phones.

3. Responsive design: Bootstrap is built with responsive design principles, which means that web pages created with Bootstrap automatically adapt to different screen sizes and resolutions, providing a consistent user experience across various devices. This eliminates the need for separate CSS code for different devices, saving development time and effort.

4. Flexibility and customization: While Bootstrap provides a set of predefined styles and components, it also allows developers to customize the look and feel of their web applications by overriding or extending the default styles. This flexibility allows developers to create unique and branded web designs that meet their specific requirements.

5. Community and documentation: Bootstrap has a large and active community of developers, which means that it has a vast ecosystem of resources, including documentation, tutorials, forums, and third-party plugins. This makes it easy to find help and support when using Bootstrap in web development projects.

6. Responsive grid system: Bootstrap includes a responsive grid system that provides a flexible and fluid layout for designing responsive web pages. The grid system makes it easy to create responsive web pages with multiple columns, rows, and breakpoints, ensuring that the layout looks good on different screen sizes and devices.

7. Accessibility: Bootstrap adheres to web accessibility standards, making it easier to create web applications that are accessible to people with disabilities. It includes built-in accessibility features, such as semantic markup, proper use of ARIA attributes, and keyboard navigation support.

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

The output of the given Python program will result in an AttributeError.

The error occurs because the attribute "__y" is declared with double underscores, making it a private attribute in Python. Private attributes are intended to be accessed only within the class itself and are not meant to be accessed directly from outside the class.

In the code snippet provided, the attempt to access the "__y" attribute using print(obj.__y) outside of the class will result in an AttributeError, indicating that the attribute is not accessible from outside the class.

To fix this error, you can either change the attribute name to a single underscore prefix (e.g., "_y") to indicate it as a protected attribute that can be accessed from subclasses or within the same module, or you can provide a getter method within the class to access the private attribute. Here's an example of how you can modify the code:

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

def get_y(self):
return self.__y

obj = myClass()
print(obj.get_y()) # Output: 20

In this example, a getter method get_y() is added to the class to provide access to the private attribute "__y". The get_y() method can be used to retrieve the value of "__y" from outside the class, avoiding the AttributeError.

          #include 
using namespace std;
class MyClass
{
};
int main() {
 cout<<sizeof(MyClass)<<"\n";
}
// Output:
// 1
        

The size of an empty class in C++ is typically 1 byte, although it can vary depending on the compiler and its settings.

According to the C++ standard (ISO/IEC 14882), an empty class is a class that has no non-static data members and no virtual functions. The C++ standard mandates that an object of any class, even an empty class, must have a unique address in memory. To achieve this, the C++ compilers typically assign a minimum size of 1 byte to an empty class.

This minimum size is usually due to the need to ensure that each object of the empty class has a distinct address in memory, as C++ requires that objects with distinct addresses have distinct addresses of their first byte. This allows C++ to ensure that objects of the empty class can be distinguished from each other in terms of their memory addresses, even though they don't have any data members or virtual functions.

In Python, a list and a tuple are both used to store collections of items. However, there are some key differences between them:

1. Mutability: Lists are mutable, which means their elements can be modified after they are created. Tuples, on the other hand, are immutable, which means their elements cannot be modified after they are created. Once a tuple is created, its elements cannot be changed.

2. Syntax: Lists are created using square brackets ([]) and elements are separated by commas. For example: my_list = [1, 2, 3]. Tuples, on the other hand, are created using parentheses (()) and elements are separated by commas. For example: my_tuple = (1, 2, 3).

3. Performance: Tuples are generally more memory efficient and faster than lists, as they are immutable and Python does not need to allocate additional memory for them. Lists, being mutable, may require resizing of memory when elements are added or removed.

4. Use cases: Lists are commonly used when you need a dynamic, mutable collection of items that can be modified during runtime, such as when you need to add, remove, or modify elements frequently. Tuples are used when you need an immutable, fixed-size collection of items that should not be modified during runtime, such as when you want to store multiple values that are related to each other and should remain unchanged.

Here's a summary of the differences between lists and tuples in Python:

The program given below will tell you how much memory is allocated to a List or a Tuple.

          #include 
using namespace std;
class MyClass
{
};
int main() {
 cout<<sizeof(MyClass)<<"\n";
}
// Output:
// 1
        

Q15. SQL Query to find min, max, and average salary from a table?

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

          SELECT AVG(Salary) from Employee;
        

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

• Understand the role: Gather as much information about the role for which you are applying. Understand the job position and the skill set you require. Note down the educational requirements also.
• Include legit resume projects: Scan the resume manually and ensure you understand everything about the mentioned technologies in the projects you have included in the resume. Try to recall every small detail about the work you have done previously.
• You need to practice DSA: Solving Data Structure and Algorithm problems regularly will help you a lot. Go through the frequently asked DSA questions for each topic for a better understanding of the topics.
• Never give up attitude: In an interview, if you are unable to solve a question immediately, then try using a hard-solve approach and then optimize accordingly. This way you will impress the hiring managers while tackling a difficult scenario during the interview. It is also a display of leadership abilities.
• Grab hints: Take notice of all the hints provided. Interviewers will help if you get stuck. They are always prepared to give assistance to candidates. Be alert, grab the clue and move to the next step. If you can't figure out what the hint is, then it's a red flag.
• Behave professionally: Keep in mind your interpersonal skills are getting judged. How you behave during trying to solve a difficult question is being noted down. Think twice before talking.
• Think loud: Learn the way of thinking loudly. Speak what comes to your mind and demonstrate how you solved a question.
• Research & Communication: The HR interviewer will generally be quite friendly, so don't get tense. If you have good communication skills, then you will easily sail through this round. Come well prepared with answers to generic questions like self-introduction, resume walkthrough, and strengths and weaknesses. Learn about the aims and values of PwC Pvt. Ltd., and use them in the interview for a definitive advantage. This will show that you have researched well about the company.
• Mock interviews: It is highly beneficial if you give mock interviews a shot. This will give you an idea of the actual interview and what you can expect. There are many resources online. It will help in improving your confidence and presenting yourself in a better way.

Here you need to talk about the company values. Make it evident that you will also abide by the values. Talk about the recent financial news or current news about the company's products. Also, mention what you adore about the company and show that you want to learn and grow. Don't cook up any fake stuff. Be true and sincere in your approach.

Usually, a PwC software engineer's minimum salary is INR 6 lakhs and the maximum salary offered is up to INR 8.5 lakh per year for freshers. Just consider the average salary in this case.

There is no online coding round currently for PwC. However, there is an offline coding round during the interview. Coding questions will be put forward for solving in the interview process. You also need some experience in coding from scratch in the technical round. It is because you need to understand the basic code. So, learn to code from scratch as it is beneficial. You need also to understand code generation.

Nothing is difficult if the candidate's preparation is right and the determination is high. These interviews mainly focus on the resumes of candidates, coding problems (Data Structures and Algorithms), OOPs, and computer science fundamentals. You will clear the interview with flying colors if you have prepared properly.

• The job applicant should not have any arrears or active backlogs.
• The candidate should have scored 60-plus% or 6-plus CGPA throughout their academic career. (This is subject to change as per company policy).

There is no fixed time on how long the process of an interview at PwC will take. The position, the location, and the urgency are some of the factors that decide the length of the interview. PwC prefers to quicken its process so that the candidate is not kept waiting for long. Even if you have successfully cleared all the interviews, it could take more than 10 days to receive the offer letter. Generally, the interview process takes a week to a month. The job offer is given to the candidate via mail.

That's it! With this, you are one step closer to bagging your dream job.

Found these questions helpful? Here are some more articles that you may like to read:

1. Tech Mahindra Interview Questions For Technical And HR Round (2024)
2. Top Uber Interview Questions With Answers 2024 (For Freshers & Experienced)
3. Goldman Sachs Interview Questions With Answers (2024) To Help You Prepare Well!
4. Top L&T Interview Questions With Answers (2024) To Help You Ace Your Job Interview!
5. Bookmark These Morgan Stanley Interview Questions With Answers (2024)