Accenture Interview Questions

About Accenture

Accenture is a multinational professional services company that provides a wide range of services in strategy, consulting, digital technology, and operations. The company was founded in 1989 and has its headquarters in Dublin, Ireland.

Accenture offers services to clients across various industries, including finance, healthcare, technology, telecommunications, and many others. The company operates through multiple business segments, which include Strategy & Consulting, Interactive, Technology, and Operations.

Some of the key services provided by Accenture include:

1. Strategy and Consulting: Accenture helps clients develop business strategies, optimize operations, and improve organizational performance.
2. Interactive: Accenture’s Interactive division focuses on creating digital experiences and marketing strategies to enhance customer engagement and drive business growth.
3. Technology: Accenture assists clients in implementing and managing technology solutions, including cloud computing, cybersecurity, artificial intelligence, and data analytics.
4. Operations: Accenture offers services to streamline business operations, such as supply chain management, finance, human resources, and customer service.

Accenture is known for its expertise in digital transformation, helping organizations adapt to the rapidly evolving technological landscape and leverage emerging technologies to gain a competitive edge. The company employs a large workforce globally, comprising consultants, technologists, strategists, and industry experts.

Accenture Recruitment Process

Accenture, a global professional services company, follows a comprehensive recruitment process to identify and hire talented individuals. While the specific details may vary depending on the role and location, here is a general overview of Accenture’s recruitment process:

1. Online Application: The first step is to submit an application through Accenture’s career website or other job portals. You’ll need to provide your personal information, educational background, work experience, and upload your resume or CV.
2. Resume/CV Screening: Accenture’s recruiters review the received applications and screen resumes/CVs to assess candidates’ qualifications, skills, and experience. This initial screening helps identify potential matches for the desired positions.
3. Online Assessments: Shortlisted candidates are often required to complete online assessments, which may include tests to evaluate their cognitive abilities, technical skills, language proficiency, or other relevant competencies. These assessments help Accenture assess candidates’ suitability for the role.
4. Interviews: Successful candidates from the online assessments move on to the interview stage. The interview process at Accenture typically includes multiple rounds, conducted by recruiters, hiring managers, and potentially other team members. The interviews can be conducted in-person, over the phone, or through video conferencing.a. HR/Behavioral Interview: The first interview round often focuses on assessing candidates’ behavioral competencies, past experiences, and their alignment with Accenture’s core values. Typical questions may revolve around teamwork, problem-solving, leadership, and adaptability.b. Technical Interview: For roles that require technical expertise, a technical interview may be conducted to evaluate candidates’ knowledge and skills in their respective fields. This interview may involve questions related to specific technologies, coding exercises, system design problems, or other technical aspects.c. Case Interview: In some cases, candidates may be required to participate in a case interview. This interview assesses their problem-solving abilities and how well they can analyze and solve business-related scenarios.
5. Additional Assessments: Depending on the role, candidates may be asked to complete additional assessments, such as group discussions, presentations, or case studies. These activities provide a deeper understanding of candidates’ abilities to collaborate, communicate, and analyze complex situations.
6. Offer and Onboarding: After the interview process, the selected candidate will receive an offer letter detailing the terms of employment, including salary, benefits, and other relevant information. Once the offer is accepted, the candidate goes through the onboarding process, which includes completing necessary paperwork and joining Accenture.

It’s important to note that the exact process may vary, and there may be additional steps or variations specific to certain roles or locations within Accenture. It’s always advisable to refer to the specific job posting or contact Accenture’s recruitment team for the most accurate and up-to-date information regarding their recruitment process.

Accenture Technical Interview Questions: Freshers and Experienced

Q 1). What is the use of “static” keyword in Java?

Ans: In Java, the “static” keyword is used to define class-level members that belong to the class itself rather than individual instances (objects) of the class. When a member (variable or method) is declared as static, it means there will be only one copy of that member shared across all instances of the class. Here are the main uses of the “static” keyword in Java:

1.)Static Variables (Class Variables): Static variables are shared among all instances of a class. When a variable is declared as static, it is associated with the class itself rather than any particular object. Any changes made to a static variable will be reflected in all instances of the class. They are useful for maintaining data that is common to all instances. Static variables are initialized only once, at the start of the program, and retain their values until the program terminates.

2.)Static Methods: Static methods are associated with the class rather than any particular instance of the class. They can be called directly using the class name, without the need to create an object of the class. These methods are often utility methods or helper functions that don’t depend on instance-specific data.

3.) Static blocks are used to initialize static variables or perform some class-level setup tasks. They are executed only once, when the class is first loaded into memory, before any static methods or variables are accessed.

Q2.) Implement a sorting algorithm (e.g., Bubble Sort, Quick Sort) and analyze its time complexity for a large dataset.

Ans: Bubble Sort Algorithm:

Bubble Sort is a simple comparison-based sorting algorithm. It repeatedly steps through the list to be sorted, compares adjacent elements, and swaps them if they are in the wrong order. The pass through the list is repeated until the list is sorted.

Here’s the Python implementation of Bubble Sort:

def bubble_sort(arr):
    n = len(arr)
    for i in range(n):
        # Flag to check if any swaps occurred in this iteration
        swapped = False

        # Last i elements are already in place, so we don't need to check them
        for j in range(0, n - i - 1):
            # Swap if the element found is greater than the next element
            if arr[j] > arr[j + 1]:
                arr[j], arr[j + 1] = arr[j + 1], arr[j]
                swapped = True

        # If no two elements were swapped in the inner loop, the array is already sorted
        if not swapped:
            break

    return arr

Time Complexity Analysis:

The time complexity of Bubble Sort can be analyzed as follows:

• Best-case Time Complexity: O(n) – Occurs when the array is already sorted. In this case, the algorithm will perform a single pass without any swaps.
• Average-case Time Complexity: O(n^2) – In the average case, the algorithm will perform n passes, and in each pass, it compares n-i-1 elements (where i is the pass number).
• Worst-case Time Complexity: O(n^2) – Occurs when the array is sorted in reverse order. In this case, the algorithm will perform n passes, and in each pass, it compares n-i-1 elements (where i is the pass number).

The best-case time complexity is better than the average and worst-case because it involves a single pass without any swaps. However, it is still not efficient for large datasets compared to other more advanced sorting algorithms like Quick Sort or Merge Sort, which have an average-case time complexity of O(n log n).

Testing the Bubble Sort Algorithm:

Let’s test the Bubble Sort algorithm on a large dataset and measure its execution time:

import random
import time

# Generate a large random dataset
data_size = 10000
data = [random.randint(1, 100000) for _ in range(data_size)]

# Measure the execution time of Bubble Sort
start_time = time.time()
sorted_data = bubble_sort(data)
end_time = time.time()

# Calculate the execution time in seconds
execution_time = end_time - start_time

print(f"Execution time for Bubble Sort on a dataset of size {data_size}: {execution_time:.5f} seconds.")

3.) Design a data structure and algorithm to efficiently find the shortest path between two nodes in a graph.

Ans : To efficiently find the shortest path between two nodes in a graph, we can use Dijkstra’s algorithm, which is a well-known algorithm for finding the shortest path in weighted graphs with non-negative edge weights. The algorithm maintains a priority queue (usually implemented with a min-heap) to explore nodes in increasing order of their distance from the source node. Here’s a step-by-step guide on how to implement Dijkstra’s algorithm:

1. Define the Data Structures:
   • Graph: Represent the graph using an adjacency list or an adjacency matrix. An adjacency list is more space-efficient for sparse graphs.
   • Priority Queue: Use a min-heap to efficiently retrieve the node with the smallest distance from the source.
2. Initialize Data Structures:
   • Set the distance of the source node to 0 and all other nodes to infinity.
   • Add the source node to the priority queue.
3. Dijkstra’s Algorithm:
   • While the priority queue is not empty:
     • Extract the node with the smallest distance from the priority queue (let’s call it current).
     • For each neighbor neighbor of current:
       • Calculate the potential new distance to neighbor by adding the weight of the edge from current to neighbor to the distance of current.
       • If the potential new distance is smaller than the current distance of neighbor:
         • Update the distance of neighbor to the potential new distance.
         • Update the previous node of neighbor to current.
         • Add neighbor to the priority queue.
4. Backtrack to Find the Shortest Path:
   • After the algorithm finishes, you can reconstruct the shortest path from the source node to the target node by backtracking from the target node to the source node using the recorded previous nodes.

Pseudocode for Dijkstra’s algorithm:

function dijkstra(graph, source, target):
    distances = {node: infinity for node in graph}
    distances[source] = 0
    previous_nodes = {node: None for node in graph}
    priority_queue = MinHeap()  # MinHeap stores nodes sorted by their distance from the source.
    priority_queue.insert((source, 0))

    while not priority_queue.empty():
        current, current_distance = priority_queue.extract_min()

        if current == target:
            break

        for neighbor, weight in graph[current]:
            distance_to_neighbor = current_distance + weight

            if distance_to_neighbor < distances[neighbor]:
                distances[neighbor] = distance_to_neighbor
                previous_nodes[neighbor] = current
                priority_queue.insert((neighbor, distance_to_neighbor))

    shortest_path = []
    current_node = target
    while current_node is not None:
        shortest_path.insert(0, current_node)
        current_node = previous_nodes[current_node]

    return shortest_path, distances[target]

The graph parameter should be a dictionary where the keys represent nodes, and the values are lists of tuples (neighbor, weight), representing the neighbors and edge weights of each node.

The time complexity of Dijkstra’s algorithm using a binary heap for the priority queue is O((V + E) log V), where V is the number of nodes and E is the number of edges. For dense graphs, using a Fibonacci heap can reduce the complexity to O(V^2 + E).

Q4.) Create a SQL query to retrieve the top 5 customers with the highest total purchase amounts from a sales database.

Ans : To retrieve the top 5 customers with the highest total purchase amounts from a sales database, you can use the following SQL query. Assuming you have a table named “sales” with columns “customer_id” and “purchase_amount”:

SELECT customer_id, SUM(purchase_amount) AS total_purchase_amount
FROM sales
GROUP BY customer_id
ORDER BY total_purchase_amount DESC
LIMIT 5;

Explanation:

1. The query selects the “customer_id” and calculates the total purchase amount for each customer using the SUM() function.
2. The GROUP BY customer_id groups the results by each customer’s ID so that the SUM() function calculates the total purchase amount for each customer.
3. The ORDER BY total_purchase_amount DESC orders the results in descending order based on the total purchase amount, so the customers with the highest purchase amounts will be at the top.
4. The LIMIT 5 ensures that only the top 5 customers are returned in the result set.

Q5.) Implement a binary search algorithm in C++ to efficiently search for a given element in a sorted array.

Ans:

#include <iostream>
#include <vector>

// Binary search function
int binarySearch(const std::vector<int>& arr, int target) {
    int left = 0;
    int right = arr.size() - 1;

    while (left <= right) {
        int mid = left + (right - left) / 2;

        if (arr[mid] == target) {
            return mid; // Element found at index 'mid'
        } else if (arr[mid] < target) {
            left = mid + 1; // Search in the right half
        } else {
            right = mid - 1; // Search in the left half
        }
    }

    return -1; // Element not found in the array
}

int main() {
    std::vector<int> sortedArray = {1, 3, 5, 7, 9, 11, 13, 15, 17, 19};
    int target = 11;

    int result = binarySearch(sortedArray, target);

    if (result != -1) {
        std::cout << "Element found at index: " << result << std::endl;
    } else {
        std::cout << "Element not found in the array." << std::endl;
    }

    return 0;
}

Q 6.) Design a relational database schema for an e-commerce platform that includes tables for products, categories, users, and orders.

Ans : Designing a relational database schema for an e-commerce platform involves understanding the entities involved and their relationships. Below is a basic outline for the tables and their attributes:

1. Products table:
   • product_id (Primary key)
   • product_name
   • description
   • price
   • quantity_in_stock
   • category_id (Foreign key referencing the Categories table)
2. Categories table:
   • category_id (Primary key)
   • category_name
3. Users table:
   • user_id (Primary key)
   • username
   • email
   • password_hash (or any secure representation of the password)
   • shipping_address
   • billing_address
4. Orders table:
   • order_id (Primary key)
   • order_date
   • user_id (Foreign key referencing the Users table)
   • total_amount
   • order_status (e.g., “pending,” “shipped,” “delivered,” etc.)
5. Order_Items table (to handle the many-to-many relationship between orders and products):
   • order_item_id (Primary key)
   • order_id (Foreign key referencing the Orders table)
   • product_id (Foreign key referencing the Products table)
   • quantity
   • item_total_price

This schema allows for a clear representation of products, their categories, registered users, and order-related information. Here are some additional notes:

• The “product_id” in the Products table and the “category_id” in the Categories table are used as primary keys.
• The “category_id” in the Products table is a foreign key referencing the “category_id” in the Categories table, establishing a relationship between products and their categories.
• The “user_id” in the Orders table is a foreign key referencing the “user_id” in the Users table, connecting orders to the respective users who placed them.
• The Order_Items table handles the many-to-many relationship between orders and products. It contains a foreign key “order_id” referencing the Orders table and another foreign key “product_id” referencing the Products table. The “quantity” attribute represents the number of a particular product ordered, and “item_total_price” represents the total price for that quantity of the product in the order.
• The “password_hash” in the Users table should be a secure representation of the user’s password to ensure data security.

Remember that this is a basic outline, and depending on the specific requirements of your e-commerce platform, you may need to add more attributes or additional tables to handle other features like reviews, ratings, shipping details, payment information, etc.

Q7) Implement a function to check if a given string is a palindrome or not.

Ans : A palindrome is a string that reads the same backward as forward. To check if a given string is a palindrome, you can use the following Python function:

def is_palindrome(input_string):
    # Remove spaces and convert the input string to lowercase
    cleaned_string = ''.join(input_string.lower().split())

    # Compare the cleaned string with its reverse
    return cleaned_string == cleaned_string[::-1]

You can use this function to check if a string is a palindrome or not:

# Example usage:
test_string_1 = "racecar"
test_string_2 = "hello"
test_string_3 = "A man, a plan, a canal, Panama"

print(is_palindrome(test_string_1))  # Output: True
print(is_palindrome(test_string_2))  # Output: False
print(is_palindrome(test_string_3))  # Output: True

The function first removes spaces from the input string and converts it to lowercase to handle cases with different capitalizations and spaces. Then, it compares the cleaned string with its reverse using slicing ([::-1]) to check if it’s a palindrome. If the cleaned string and its reverse are the same, the function returns True, indicating that the input string is a palindrome. Otherwise, it returns False.

Q8) Write a function to reverse a singly linked list.

Ans: To reverse a singly linked list, you need to modify the links between the nodes, so the last node becomes the first node, and the first node becomes the last node. Here’s a Python function to achieve this:

class ListNode:
    def __init__(self, value=0, next=None):
        self.value = value
        self.next = next

def reverse_linked_list(head):
    # If the linked list is empty or has only one node, it is already reversed.
    if not head or not head.next:
        return head

    prev_node = None
    current_node = head
    next_node = None

    while current_node:
        next_node = current_node.next
        current_node.next = prev_node
        prev_node = current_node
        current_node = next_node

    return prev_node

Here’s how the function works:

1. The function takes the head of the linked list as input.
2. It checks if the linked list is empty or has only one node. If so, it returns the head as it is already reversed.
3. If the linked list has more than one node, it proceeds with the reversing process.
4. It uses three pointers: prev_node, current_node, and next_node. prev_node keeps track of the previous node, current_node is the current node being processed, and next_node is used to keep track of the next node to process.
5. It iterates through the linked list, updating the next pointer of the current_node to point to the prev_node, effectively reversing the link.
6. After reversing the link, it moves the current_node and prev_node pointers to the next nodes.
7. Once the loop is completed, the prev_node will be pointing to the last node of the original list, which is now the head of the reversed list. So, the function returns prev_node.

You can use this function to reverse a singly linked list like this:

# Example usage:
# Assuming you have a linked list: 1 -> 2 -> 3 -> 4 -> 5 -> None
# And you want to reverse it to: 5 -> 4 -> 3 -> 2 -> 1 -> None

# Create the linked list
head = ListNode(1)
head.next = ListNode(2)
head.next.next = ListNode(3)
head.next.next.next = ListNode(4)
head.next.next.next.next = ListNode(5)

# Reverse the linked list
reversed_head = reverse_linked_list(head)

# Print the reversed linked list
current_node = reversed_head
while current_node:
    print(current_node.value, end=" -> ")
    current_node = current_node.next
# Output: 5 -> 4 -> 3 -> 2 -> 1 ->

Q9) Write a function to validate whether a given string is a valid email address or not.

Ans : To validate whether a given string is a valid email address or not, you can use regular expressions. Regular expressions are powerful tools for pattern matching and can help you ensure that the email address follows the correct format. Here’s a Python function that uses regular expressions to validate an email address:

import re

def is_valid_email(email):
    # Regular expression pattern for validating email addresses
    email_pattern = r'^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$'
    
    # Use re.match() to check if the email matches the pattern
    if re.match(email_pattern, email):
        return True
    else:
        return False

Usage:

print(is_valid_email("john.doe@example.com")) # True
print(is_valid_email("invalid_email")) # False
print(is_valid_email("hello@world")) # False
print(is_valid_email("john@example")) # False

Explanation of the regular expression email_pattern:

• ^: Matches the start of the string.
• [a-zA-Z0-9._%+-]+: Matches one or more occurrences of letters (both uppercase and lowercase), digits, periods, underscores, percentage signs, plus signs, and hyphens. This covers the local part of the email address before the ‘@’ symbol.
• @: Matches the ‘@’ symbol.
• [a-zA-Z0-9.-]+: Matches one or more occurrences of letters (both uppercase and lowercase), digits, periods, and hyphens. This covers the domain name part of the email address.
• \.: Matches a literal period (‘.’). We use the backslash to escape the period because a period in a regular expression is a special character that matches any character.
• [a-zA-Z]{2,}: Matches two or more occurrences of letters (both uppercase and lowercase). This ensures that the domain name has at least two letters (e.g., “.com”, “.org”).
• $: Matches the end of the string.

The function uses re.match() to check if the given email string matches the email_pattern. If it does, the function returns True, indicating that the email is valid; otherwise, it returns False.

Q10.) Implement a recursive algorithm to calculate the factorial of a given non-negative integer.

Ans : The factorial of a non-negative integer is the product of all positive integers less than or equal to that number. To calculate the factorial recursively, you can use the following algorithm in Python:

def factorial(n):
    if n == 0:
        return 1
    else:
        return n * factorial(n - 1)

Let’s understand how the recursive function works:

1. The base case: If the input n is 0, the factorial is defined as 1, so we return 1.
2. Recursive step: If n is greater than 0, the factorial of n is calculated by multiplying n with the factorial of (n-1). The function calls itself with the argument (n-1) until it reaches the base case (n == 0).

Here’s an example of how you can use the factorial function:

num = 5
result = factorial(num)
print(f"The factorial of {num} is {result}")

Output:

The factorial of 5 is 120

This recursive algorithm calculates the factorial of the given non-negative integer efficiently. However, keep in mind that recursive solutions might lead to stack overflow errors for very large inputs due to excessive function calls. For practical use cases, you can consider using an iterative solution instead.