Mphasis Programming Questions 2026: Syllabus and 8 Worked Solutions

The Mphasis programming round has 25 multiple-choice questions, a 35-minute timer, and a syllabus that maps directly to the AMCAT computer programming module. The questions test data structures, algorithms, OOP, and complexity analysis, not live coding. That difference shapes the entire prep strategy.

For the full picture of where this round sits in the Mphasis selection sequence, see the Mphasis recruitment process, test pattern, and eligibility guide.

Mphasis Programming Test Pattern

Three facts to anchor your prep:

• 25 MCQs, 35 minutes — an average of 84 seconds per question.
• No live coding. Every question is multiple-choice with four options.
• Platform: AMCAT, run by SHL India. The question style and difficulty calibration match the AMCAT computer programming practice bank directly.

Feature	Detail
Questions	25 MCQs
Time	35 minutes
Question type	Multiple choice, 4 options
Delivery	AMCAT platform
Negative marking	Not standard on AMCAT programming module

Definition questions (for example, “which data structure is used for X”) should take 20 to 30 seconds. Complexity analysis and expression conversion questions need a short mental trace; budget 60 to 90 seconds for those. The split between easy and harder questions is what makes time management count.

Syllabus: Topics Covered in the Programming Round

The AMCAT computer programming syllabus covers six topic clusters. Mphasis tests from all of them, with data structures and algorithms carrying the most weight:

Topic Cluster	What It Tests
Data Structures	Trees, linked lists, arrays, stacks, queues — operations, properties, use-cases
Algorithms	Sorting (quicksort, merge sort, bubble sort, insertion sort), searching, recursion
Object-Oriented Programming	Inheritance, polymorphism, encapsulation, abstraction — including compile-time vs. runtime distinctions
Complexity Analysis	Big-O notation, time and space complexity for standard DS and algorithm operations
Mathematical Concepts	Combinatorics and number theory applied to programming problems
Language Concepts	C/C++ pointer semantics, Java OOP basics, memory management

Language-specific syntax questions appear but are few. Conceptual understanding of OOP and data structure behaviour carries more weight than remembering exact syntax.

For the aptitude and verbal sections of the same test, see the Mphasis online test pattern, syllabus, and placement papers guide.

Sample Questions with Worked Solutions

The eight questions below are representative of the AMCAT programming module format. Every answer is re-derived from first principles. The earlier version of this article had an arithmetically incorrect answer for Q1 (the tree-node-count problem); the correct derivation is shown below.

Data Structures

• Q1: A tree has 5 levels. Each non-leaf node has exactly 4 children. How many total nodes does the tree contain?

  • a) 341
  • b) 256
  • c) 1,024
  • d) None of these

• Answer: a) 341

• Working:

  • Level 1 (root): 4^0 = 1 node
  • Level 2: 4^1 = 4 nodes
  • Level 3: 4^2 = 16 nodes
  • Level 4: 4^3 = 64 nodes
  • Level 5: 4^4 = 256 nodes
  • Total = 1 + 4 + 16 + 64 + 256 = 341
  • Geometric series check: (4^5 - 1) / (4 - 1) = 1,023 / 3 = 341 ✓
  • Note: 1,024 is 4^5, which counts only the leaf nodes at level 5, not the whole tree. The earlier article cited 1,024 as the answer; that is incorrect.

• Q2: Which data structure is used to convert an infix expression to a postfix expression?

  • a) Queue
  • b) Linked List
  • c) Stack
  • d) Tree

• Answer: c) Stack

• Working:

  • The shunting-yard algorithm processes tokens left to right.
  • Operands go directly to output.
  • Operators are pushed to a stack and popped to output when a lower-or-equal-precedence operator arrives.
  • The Last-In-First-Out behaviour of a stack matches exactly how operator precedence needs to be resolved.

• Q3: The postfix form of ((A + B) * C - (D - E) ^ (F + G)) is:

  • a) AB+C*DE-FG+^-
  • b) AB+C*DE-F-G+^
  • c) ABC+*DE-FG+^-
  • d) ^-*+ABCDE-FG+

• Answer: a) AB+C*DE-FG+^-

• Working:

  • Step 1: (A + B) converts to AB+
  • Step 2: AB+ * C gives AB+C*
  • Step 3: (D - E) converts to DE-
  • Step 4: (F + G) converts to FG+
  • Step 5: (D - E) ^ (F + G) gives DE-FG+^
  • Step 6: whole expression (AB+C*) minus (DE-FG+^) gives AB+C*DE-FG+^-

• Q4: For dynamic node allocation in tree construction, which data structure is most commonly used?

  • a) Array
  • b) Linked List
  • c) Stack
  • d) Queue

• Answer: b) Linked List

• Working:

  • A tree node stores data plus pointers to its children, which is the same node-plus-pointer structure as a linked list node.
  • Arrays work for complete binary trees stored as heaps, but require pre-allocated contiguous memory.
  • For general trees with variable branching, the linked-node approach handles arbitrary sizes without reallocation.
  • Stacks and queues assist tree traversal, not construction.

Algorithms

• Q5: Which of the following is NOT a standard sorting algorithm classification?

  • a) Insertion sort
  • b) Selection sort
  • c) Exchange sort (Bubble sort)
  • d) Deletion sort

• Answer: d) Deletion sort

• Working:

  • Insertion, Selection, and Exchange (Bubble) are the three classical sorting strategy categories.
  • “Deletion” is an operation on a data structure, specifically removing an element. It is not a sorting method.

• Q6: What is the time complexity of Merge Sort in all cases (best, average, and worst)?

  • a) O(n)
  • b) O(n log n)
  • c) O(n²)
  • d) O(log n)

• Answer: b) O(n log n)

• Working:

  • Merge Sort splits the array into two halves at each recursive call: log n levels of splitting.
  • At each level, the merge step processes all n elements: O(n) per level.
  • Recurrence: T(n) = 2T(n/2) + O(n), which solves by the Master Theorem to O(n log n).
  • This holds for best, average, and worst cases, unlike Quicksort, which degrades to O(n²) on sorted input without randomisation.

Object-Oriented Programming

• Q7: Which OOP concept allows a subclass to provide its own implementation of a method defined in the parent class, with the same method signature?
  • a) Encapsulation
  • b) Abstraction
  • c) Method overriding
  • d) Method overloading
• Answer: c) Method overriding
• Working:
  • Method overriding is runtime polymorphism: the subclass redefines a parent method with the identical signature.
  • Method overloading is compile-time polymorphism: same method name, different parameter types or count.
  • Encapsulation bundles data and methods into a class; abstraction hides implementation details behind an interface.

Complexity Analysis

• Q8: What is the time complexity of Binary Search on a sorted array of n elements?
  • a) O(n)
  • b) O(n²)
  • c) O(log n)
  • d) O(n log n)
• Answer: c) O(log n)
• Working:
  • Binary Search halves the search space at each comparison.
  • After 1 comparison: n/2 elements remain. After 2: n/4. After k: n / (2^k).
  • Search ends when n / (2^k) = 1, giving k = log₂(n).
  • Hence time complexity is O(log n).

How to Prepare for Mphasis Programming MCQs

The programming round tests conceptual understanding, not syntax recall. A student who knows why a stack is used for infix-to-postfix conversion will answer faster than one who memorised a list of stack use-cases.

Prioritised prep order:

1. Data structures first. Trees (binary, n-ary, BSTs), linked lists, stacks, and queues account for the largest share of questions. Focus on operations (insert, delete, search) and properties (height, depth, traversal order). Infix-to-postfix and prefix-to-infix conversions using stacks appear consistently.
2. Big-O notation. Know the time and space complexity of the standard sorting algorithms — merge sort, quicksort, bubble sort, insertion sort — and searching algorithms — binary search, linear search. The AMCAT module tests these directly.
3. OOP concepts. Understand the four pillars — encapsulation, abstraction, inheritance, polymorphism — and the distinction between compile-time and runtime polymorphism. Method overriding vs. overloading questions are common.
4. Postfix and prefix expression conversion. Practice manually with 3 to 5 expressions of varying complexity. The shunting-yard algorithm is the method to internalise.
5. Language specifics last. C/C++ pointer questions and Java OOP questions appear occasionally. Focus on the conceptual level, not syntax details.

Practice source: the AMCAT computer programming question bank uses the same question format and difficulty calibration as the actual Mphasis programming round. Work through it systematically, topic by topic.

What to Expect After the Programming Round

The Mphasis online test runs three sections in one session: aptitude, verbal, and programming. Clearing all three moves you to a technical interview. The interview shifts from MCQ recognition to applied problem-solving: the interviewer will ask you to write or trace through code, not just identify the correct option from a list.

For what the technical interview looks like and which questions come up, see the Mphasis interview questions and interview process guide for freshers.

The programming MCQ round rewards students who understand why a stack pops in LIFO order and why merge sort runs in O(n log n) while bubble sort runs in O(n²), not just the fact that they do. That mechanism-first reasoning transfers directly to working with AI systems, where the difference between a working feature and a broken one often comes down to knowing which structure fits the problem. TinkerLLM puts that same reasoning to work on real LLM tasks at ₹299: the same problem-solving instinct, applied to a different class of software.