Stack Questions at Accenture: What to Expect

Stack questions appear in about 5-5.5% of Accenture's technical assessment, based on their 8 Stack problems out of 144 total. While this may seem like a small portion, it represents a focused and predictable area you can master. Success here demonstrates core competency in handling LIFO (Last-In, First-Out) logic, which is fundamental to parsing, validation, and state-tracking problems—skills directly applicable to real-world Accenture projects in systems integration and application development.

What to Expect — Types of Problems

Accenture's Stack problems typically avoid extreme complexity, focusing instead on practical applications. You can expect these core categories:

1. Parentheses/Bracket Validation: Checking if a string containing (), {}, or [] has properly matched and nested pairs. This is a classic and highly likely question.
2. String Manipulation: Problems like simplifying file paths (/a/./b/../c/ → /a/c) or removing adjacent duplicates (abbaca → ca) are common.
3. Basic Calculator or Expression Evaluation: Solving arithmetic expressions, often focusing on handling parentheses and the correct order of operations using stacks.
4. Next Greater Element: Finding the next greater element for each item in an array is a standard pattern that efficiently uses a stack.

The problems test your ability to model a process step-by-step, using the stack to temporarily hold data for later comparison or processing.

How to Prepare — Study Tips with One Code Example

Focus on understanding the pattern, not just memorizing solutions. For each problem type, trace through the logic with a small example on paper. Then, implement it. Your goal is to recognize which scenario calls for a stack: usually when you need to track open or pending elements that must be completed or compared in reverse order.

A fundamental pattern is using a stack for matching pairs. Here is the standard solution for the Valid Parentheses problem:

def isValid(s: str) -> bool:
    stack = []
    mapping = {')': '(', '}': '{', ']': '['}

    for char in s:
        if char in mapping:  # It's a closing bracket
            top_element = stack.pop() if stack else '#'
            if mapping[char] != top_element:
                return False
        else:  # It's an opening bracket
            stack.append(char)
    return not stack  # Stack must be empty at the end

The pattern is consistent: use a stack to store opening brackets. When you encounter a closing bracket, check if it correctly matches the most recent unmatched opening bracket (the top of the stack).

Recommended Practice Order

Build your skill methodically:

1. Start with Valid Parentheses to internalize the core matching pattern.
2. Move to String problems like Remove All Adjacent Duplicates In String.
3. Practice Path Simplification (Simplify Path).
4. Tackle the Next Greater Element pattern.
5. Finally, attempt a Basic Calculator problem to combine stack operations with arithmetic logic.

This order builds from simple matching to more complex state management. Practice until you can identify the stack approach within a minute of reading a problem description.

Practice Stack at Accenture