AMCAT Coding Questions 2026: Automata and Automata Fix Guide

AMCAT has two coding modules in 2026: Automata, where you write code from a blank editor, and Automata Fix, where you debug existing code. Preparing for one without knowing the other exists is the most common mistake in AMCAT coding prep.

Both modules run on SHL India’s AMCAT platform (SHL acquired Aspiring Minds in 2019 and continues running the test under both brand names). The employer decides which module, or combination of modules, appears in your test link. This guide covers both, along with how to figure out which one you’re preparing for.

---

Two Coding Modules, Two Different Skills

The confusion is understandable: both are called “coding” sections, both run inside the AMCAT platform, and both use the same browser-based IDE. The similarity ends there.

Parameter	Automata (Standard)	Automata Fix
What you do	Write code from scratch	Debug existing buggy code
Number of questions	2 (1 easy + 1 hard)	7 questions
Time limit	~30 minutes	20 minutes
Languages supported	C, C++, Java, Python	C, C++, Java (no Python)
Graded on	Correctness, complexity, approach	Passing hidden test cases
Can you re-run code?	Yes, multiple submissions	Yes, compile and run freely

The practical implication: if Python is your strongest language, you can use it for standard Automata but not for Automata Fix. Decide your language before test day. You cannot switch mid-section.

Check the drive invitation from the recruiter or the company’s official test notice to confirm which module you’ll see. The AMCAT exam dates, fees, and pattern guide has a section on reading your test configuration email.

---

Standard Automata: What the Questions Actually Look Like

Standard Automata runs on SHL’s Automata 2.0 platform, accessible via myamcat.com. You get a problem statement and a blank editor. Your submission is auto-graded against hidden test cases for correctness, time complexity, and approach.

Four question-type categories appear across the easy and hard difficulty levels.

Array and Number Manipulation

The most common easy-level category. Typical tasks include finding the sum of elements satisfying a condition, rotating an array, or identifying the second-largest value.

• What you need: One or two loops, basic conditional logic
• Common mistake: Off-by-one errors in array traversal (using index n when valid indices are 0 through n-1)
• Approach: Trace through a small example manually before writing the loop; boundary conditions trip most submissions here

String Operations

The second most frequent category. Tasks include reversing a string, counting distinct characters, checking if a string is a palindrome, or extracting substrings matching a pattern.

• What you need: String indexing, character comparison, basic two-pointer logic for palindromes
• Watch for: Language-specific string handling — in Java, strings are immutable, so StringBuilder is the standard tool for in-place modifications
• Approach: Write a helper that prints intermediate values; remove it before final submission

Number Patterns

Classic pattern problems: print a triangle of numbers, generate the Fibonacci sequence up to N, or output the prime factors of an integer. These are almost exclusively easy-level questions.

• What you need: Nested loops, simple arithmetic, modulo operator
• Approach: Solve for 3 rows or 5 terms on paper first, then code the pattern you see

Sorting and Searching

Hard-level questions often involve a sorting variant or a searching problem with a twist, such as finding the Kth smallest element, or counting inversions in an array.

• What you need: Implementation of one standard algorithm (bubble, selection, insertion, or binary search) or knowledge of sort() from the standard library
• Approach: Prefer standard library sort for correctness; implement from scratch only when the question explicitly tests the algorithm logic

For a full four-week preparation plan, topic priority list, and the grading rubric in detail, the AMCAT Automata questions and answers guide goes deeper than this overview.

---

Automata Fix: The Three Bug Categories

Automata Fix gives you existing code. It compiles, but produces incorrect output for some or all test cases. Your job is to find and correct the bug. Three distinct bug categories appear in the test.

Syntax and Compilation Errors

The code does not compile as-is. Common causes: missing semicolons, mismatched braces, wrong data types, or incorrect function signatures.

• Q type example:
  • Bug: a for loop declared as for (int i = 0, i < n, i++) using commas instead of semicolons
  • Fix: replace commas with semicolons — for (int i = 0; i < n; i++)
• Strategy: Attempt to compile first. The compiler error message points directly to the line. Read the message, don’t guess.

Logical Errors

The code compiles and runs but produces wrong output. The algorithm is structurally correct but has a flawed condition, wrong operator, or incorrect variable.

• Q type example:
  • Bug: loop condition i <= n when array indices run from 0 to n-1
  • Fix: change to i < n to prevent out-of-bounds access
• Strategy: Trace variable values manually for a small input (3–4 elements). Most logical errors become visible on the first or second trace step.

Code Reuse (Incomplete Code)

The test provides a helper function or class already written. Your task is to implement the missing function using the provided helpers. You cannot bypass them and write a standalone solution.

• Q type example:
  • A findMax() helper is provided. You must implement findSecondMax() by calling findMax() on a modified copy of the array.
• Strategy: Read the helper’s function signature carefully before writing a single line. The return type and parameter list tell you what the calling code expects.

---

How to Split Your Prep Time

Knowing which module your target company uses shapes where to spend preparation time.

If your target drives include companies that use standard AMCAT Automata (the write-from-scratch format), the highest-return prep is:

• Solve 2–3 array or string problems daily from any standard practice platform
• Time yourself: aim to solve an easy-level question in under 12 minutes
• Practise boundary cases explicitly — empty arrays, single elements, maximum values

If you’re targeting companies known to use Automata Fix, shift your practice toward:

• Reading and tracing unfamiliar code in C, C++ or Java
• Practising bug-spotting drills: take a working piece of code, introduce one deliberate bug, then find it
• Compiling code frequently to read compiler error messages, not just fix by intuition

If you are unsure which module your company uses: prepare both. The skill overlap is real: students who debug code well also write better code, and vice versa.

The AMCAT module-wise syllabus lists all AMCAT sections (including the non-coding modules) so you can see the full test structure and allocate prep time across every section.

---

Once you have the overall module picture, the AMCAT Automata questions and answers guide is the natural next stop. It covers the standard write-from-scratch section with a question-by-difficulty breakdown, the 4-axis grading rubric, and a week-by-week preparation plan that fits a typical placement-prep window.