AMCAT Computer Programming Module Revision Map: Code, DSA and Core CS

Revise programming and core CS as separate problem types. This map shows the state, invariant, dependency or timeline to write before choosing an answer.

KnowledgeGate Team

Exam prep & CS education

Updated 30 Jul 20266 min read

“Computer programming” is often revised as one giant subject. A placement test can jump from a three-line code trace to a data-structure invariant, a database dependency or an operating-system timeline. Each rewards a different first move: a state table, a sorted-prefix check, a dependency chain or a Gantt line.

Fix the Scope First: Computer Science and Automata Fix Are Not the Same Module

The official AMCAT syllabus page presently separates Computer Science from Automata Fix. It lists operating systems and computer architecture, DBMS and computer networks under Computer Science. Automata Fix covers basic programming, control structures, conditional statements, linear and advanced data structures, and sorting and searching.

The same page presently shows 20 questions in 20 minutes for Computer Science and 7 questions in 20 minutes for Automata Fix, and those figures can change, so check the live page before your slot. For the compulsory modules, the domain choices and the way employers read each module score, read the AMCAT exam pattern guide. The page lists no module called Computer Programming, so put code tracing and data structures in the Automata Fix lane, core CS in the Computer Science lane, and treat OOP as a transferable fundamental.

Code Tracing: Turn Every Statement into a State Change

For any deterministic trace, make a table before doing mental shortcuts. Start with a = 3, b = 5. For i = 1 to 3, execute a = a + i. If the updated a is even, add it to b; otherwise subtract i from b.

i

a before

a after

branch

b after

1

3

4

even, b = 5 + 4

9

2

4

6

even, b = 9 + 6

15

3

6

9

odd, b = 15 - 3

12

The final output is 9 12. Plausible wrong answers come from checking parity before updating a, carrying b = 15 into the final answer, or compressing two statements into one. Where the snippet does not name its language, do not assume C or Python behaviour for integer division or for an expression that updates a variable twice, and write down whether indexing is zero-based whenever an index appears.

Flow chart tracing a from 3 to 4, then 6, then 9 while b moves 5 to 9, then 15, then 12 across three loop passes, ending at the output 9 12.

Data Structures and Algorithms: Track the Invariant, Not Just the Final Array

Apply insertion sort to A = [7, 2, 9, 4]. Inserting 2 gives [2, 7, 9, 4]; inserting 9 changes nothing; inserting 4 gives [2, 4, 7, 9].

Count a comparison whenever A[j] > key is evaluated, including the final failed check. The passes use 1 + 1 + 3 = 5 comparisons. Count a shift only when an element moves right: 1 + 0 + 2 = 3 shifts. This keeps comparisons and shifts distinct.

Now binary-search for 7 with zero-based indices. With low=0, high=3, mid=1 has value 4, so set low=2. Then mid=2 has value 7, so the answer is index 2. Its precondition is sorted input.

For step-by-step practice on the same structures, the DSA using Java course works through sorting, searching and the invariant each one preserves.

Rapid invariants: a stack pops the last item pushed; a queue removes the first item enqueued; binary search requires sorted input; insertion sort leaves its left prefix sorted after every pass.

OOP: Separate the Reference Type from the Runtime Object

Consider this Java-style example:

class Base { int score(int x) { return x + 2; } }
class Derived extends Base { int score(int x) { return 3 * x; } }
Base ref = new Derived();
System.out.println(ref.score(4));

The runtime object is Derived, so overriding selects 3 * 4 and prints 12, not 6.

Feature

Overriding

Overloading

Method form

Same signature in parent and child

Different parameter lists

Choice

Runtime

Compile time

Trap

A base-typed reference can still call the child implementation

The compiler chooses from the declared call shape

The current official syllabus page names OOP in neither the Computer Science nor the Automata Fix list, so treat it as transferable ground rather than a bookable topic. A base-typed reference calling a child method is exactly the line an Automata Fix repair turns on.

DBMS: Follow Keys and Dependencies Before Writing SQL

Take R(StudentId, StudentName, DeptId, DeptName) with (101, Asha, 10, CSE), (102, Ravi, 20, ECE) and (103, Neha, 10, CSE). Given StudentId → StudentName, DeptId and DeptId → DeptName, there is a transitive dependency: StudentId → DeptId → DeptName.

Decompose it into Student(StudentId, StudentName, DeptId) and Department(DeptId, DeptName) to remove the repeated name. On Student, SELECT DeptId, COUNT(*) AS n FROM Student GROUP BY DeptId ORDER BY DeptId; returns (10, 2) followed by (20, 1). COUNT(*) includes Asha and Neha in department 10. Grouping by student name answers a different question.

Use four checks: identify the key, write the functional dependencies, find any partial or transitive dependency, then verify what each SQL clause changes. The official page also names TRC and DRC: tuple relational calculus picks whole tuples that satisfy a predicate, domain relational calculus picks individual attribute values, and both describe the selections SQL writes with WHERE. Recognise the two notations on sight.

Operating Systems and Architecture: Draw the Timeline Before Calculating

For FCFS, take P1(arrival 0, burst 5), P2(arrival 1, burst 3) and P3(arrival 2, burst 1). The Gantt chart is P1: 0-5, P2: 5-8, P3: 8-9.

Completion times are 5, 8, 9. Turnaround times are completion minus arrival: 5-0=5, 8-1=7, 9-2=7. Waiting time is turnaround minus burst: 5-5=0, 7-3=4, 7-1=6. Average waiting time is (0+4+6)/3 = 10/3 ≈ 3.33 time units. A common error is subtracting burst from completion without accounting for arrival.

FCFS Gantt chart with P1 from 0 to 5, P2 from 5 to 8 and P3 from 8 to 9, arrivals marked at 0, 1 and 2, and waiting times 0, 4 and 6 averaging 3.33.

Architecture usually arrives as a one-line calculation rather than a timeline. With a 10 ns cache, 100 ns main memory and a hit ratio of 0.9, average access time is 0.9 x 10 + 0.1 x 100, which is 9 + 10 = 19 ns. The 10 percent of misses supply 10 of those 19 ns, so the hit ratio moves the answer far more than cache speed does.

The rest of the Computer Science lane splits the same way: CPU scheduling and process synchronisation with OS, cache, memory hierarchy and I/O with architecture, routing and protocol layers with networks.

How These Concepts Become Test Questions, and Where Marks Leak

Lane

What the official description checks

Your action

Automata Fix

Repair a logical or syntax error, or complete code by reusing functions

Trace the state and test the changed line

Computer Science

Knowledge and understanding across the listed core-CS areas

Define the concept, draw the structure or timeline, then calculate

Use these five prompts as a quick self-check. Cover each answer until you have attempted its prompt.

  1. What is the final loop output?

    Answer: 9 12. Checking parity before updating a produces the wrong path.

  2. How many insertion-sort comparisons and shifts occur?

    Answer: 5 comparisons and 3 shifts. Stopping before a failed condition undercounts comparisons.

  3. What does ref.score(4) print?

    Answer: 12, because runtime dispatch selects Derived.score.

  4. What are the department counts?

    Answer: (10, 2), (20, 1). Grouping by StudentName returns three rows instead of two.

  5. What is the FCFS average wait?

    Answer: 10/3 ≈ 3.33 time units. Averaging turnaround instead of waiting time gives 19/3.

Do not prepare for a full coding round when your immediate task is concept revision. If your assessment requires complete programs, switch to a separate coding round strategy for placements.

A 90-Minute Revision Map and the Short Version

Use one controlled cycle: minutes 0-10, verify the live AMCAT module choice and rewrite the scope map; 10-30, trace two code snippets; 30-45, do one sort or search and one stack or queue item; 45-60, solve one dependency plus one SQL output; 60-75, draw one OS timeline and recall architecture and network definitions; 75-90, redo only the questions marked wrong. Move a missed block to the next cycle rather than squeezing it into the final five minutes.

The short version: trace state changes, preserve the data-structure invariant, distinguish runtime dispatch, follow dependencies before SQL, draw scheduling timelines, and verify the current official pattern instead of memorising an old screenshot. Use AMCAT Superset as the structured next step, then browse the IT Recruitment Exams category for the broader live course path.