GATE CS & DA Preparation Guide Module 2 – A preparation system: plan, official papers and error logs

A GATE study plan built from the official syllabus

Turn the GATE CS, DA and GA syllabi into a checklist of clauses, size each section from a diagnostic, and plan the weeks backwards from the exam.

Beginner
20 minutes
Examples run with Python 3.14.8 and Pyodide 314.0.7
By MySmartCoPilot

What you will learn

Convert the official syllabus into a checklist of clauses mapped to lessons and practice
Rank the parts of the paper by the marks the brochure fixes for them, per clause
Estimate hours per section from your diagnostic results and the time left before the exam
Plan learning, practice, testing and revision phases with a weekly review

Before you start

GATE CS, DA or both papers: overlap and choice

What you’ll learn · Before you start

What you will learn

Convert the official syllabus into a checklist of clauses mapped to lessons and practice
Rank the parts of the paper by the marks the brochure fixes for them, per clause
Estimate hours per section from your diagnostic results and the time left before the exam
Plan learning, practice, testing and revision phases with a weekly review

Before you start

GATE CS, DA or both papers: overlap and choice

On this page

Split into items you can tick off one at a time, the GATE 2027 CS syllabus holds 55 in its 10 sections and the DA syllabus 38 in its 7, and General Aptitude: The section every GATE paper shares: 10 questions worth 15 marks, five of 1 mark and five of 2, with a syllabus of its own. More in “MCQ, MSQ and NAT: GATE marking and when to guess” adds 8 to either paper. A study plan built from the syllabus gives every one of those items a week, so that none of them is met for the first time in the exam hall. It splits each section into these syllabus clause: One short item of a section of an official GATE syllabus, in the syllabus's own words, such as "Design of control unit – hardwired and microprogrammed": the unit a study plan gives a week, a lesson and three marks., measures how weak you are in each section with a short diagnostic: A short timed set of about ten unseen exam-level questions on one section, scored with GATE marking, whose score decides how much study time the section gets in a plan., counts the hours you really have and lays the weeks out backwards from your first exam day: learning one section at a time, then timed tests that mix the sections, then full-length mock: An unseen GATE paper of 65 questions taken in one sitting of 180 minutes under the exam's own rules, scored with GATE marking and analysed on the same day. More in “Full-length mocks and the final month before GATE” and revision.

Below, the three syllabi become a checklist you can tick, a program you can edit shares out the hours and checks that every clause gets exactly one week, and a weekly review keeps the plan honest. No plan can promise a score.

Not affiliated

GATE 2027 is organised by IIT Madras and run jointly by IISc and the IITs; MySmartCoPilot is not affiliated with any of them. The syllabus PDFs on the official website define what each paper may ask, so if they are revised, rebuild your checklist from the new files.

Start from the clauses, not a timetable

Coaching timetables and lists of “important chapters” come from someone’s reading of earlier papers. The official syllabus is the only document that says what the 2027 papers may ask, and it changes. For 2027 the CS syllabus was rewritten in three of its ten sections: digital logic now names its minimisation methods (the algebraic technique, Karnaugh maps and the tabular method), computer organisation adds the design of hardwired and microprogrammed control units, and computer networks no longer names ARP, DHCP, ICMP, UDP, SMTP or FTP, all of which the 2026 syllabus listed. A timetable carried over from an earlier year spends hours on what was dropped and misses what was added.

A clause is an item you can learn, practise and tick off. “Design of control unit – hardwired and microprogrammed” is one; the computer organisation section has six. This track keeps the clauses of all three syllabi as data, in the official wording, each with the lesson of this track that teaches it:

The GATE 2027 syllabi as a checklist of clauses

CS · plan/cs.csv

section,clause,lesson
1,Propositional and first order logic,logic-sets-and-algebraic-structures
1,"Sets, relations, functions, partial orders and lattices",logic-sets-and-algebraic-structures
1,"Monoids, Groups",logic-sets-and-algebraic-structures
1,"Graphs: connectivity, matching, colouring",graphs-and-combinatorics
1,"Combinatorics: counting, recurrence relations, generating functions",graphs-and-combinatorics
1,"Linear Algebra: Matrices, determinants, system of linear equations, eigenvalues and eigenvectors, LU decomposition",linear-algebra-core
1,"Calculus: Limits, continuity and differentiability, Maxima and minima, Mean value theorem, Integration",calculus-and-optimisation
1,"Probability and Statistics: Random variables, Uniform, normal, exponential, Poisson and binomial distributions. Mean, median, mode and standard deviation. Conditional probability and Bayes theorem",probability-and-statistics
2,"Boolean algebra and minimization - algebraic technique, Karnaugh map, tabular method",boolean-minimisation
2,Design of combinational and sequential circuits,circuits-and-number-representation
2,Number representation and arithmetic (fixed and floating point),circuits-and-number-representation
3,Instruction set and addressing modes,isa-alu-and-control-unit
3,Design of arithmetic and logic unit (ALU),isa-alu-and-control-unit
3,Design of control unit - hardwired and microprogrammed,isa-alu-and-control-unit
3,"Memory interfacing and hierarchy: performance, cache memory mapping",memory-hierarchy-and-cache-mapping
3,I/O interface (interrupt and DMA),pipelining-hazards-and-io
3,"Instruction pipelining, pipeline hazards",pipelining-hazards-and-io
4,Programming in C,programming-and-data-structures-in-c
4,Recursion,programming-and-data-structures-in-c
4,"Arrays, stacks, queues, linked lists",programming-and-data-structures-in-c
4,"trees, binary search trees, binary heaps",programming-and-data-structures-in-c
4,graphs,programming-and-data-structures-in-c
5,"Searching, sorting, hashing",complexity-searching-sorting-hashing
5,Asymptotic worst case time and space complexity,complexity-searching-sorting-hashing
5,"Algorithm design techniques: greedy, dynamic programming and divide-and-conquer",algorithm-design-and-graph-algorithms
5,"Graph traversals, minimum spanning trees, shortest paths",algorithm-design-and-graph-algorithms
6,Regular expressions and finite automata,regular-languages-and-automata
6,Context-free grammars and push-down automata,cfl-pda-and-turing-machines
6,"Regular and context-free languages, pumping lemma",regular-languages-and-automata cfl-pda-and-turing-machines
6,Turing machines and undecidability,cfl-pda-and-turing-machines
7,"Lexical analysis, parsing",lexing-and-parsing
7,syntax-directed translation,sdt-runtime-and-optimisation
7,Runtime environments,sdt-runtime-and-optimisation
7,Intermediate code generation,sdt-runtime-and-optimisation
7,"Local optimisation, Data flow analyses: constant propagation, liveness analysis, common sub expression elimination",sdt-runtime-and-optimisation
8,System calls,operating-systems-for-gate
8,"processes, threads",operating-systems-for-gate
8,inter-process communication,operating-systems-for-gate
8,concurrency and synchronization,operating-systems-for-gate
8,Deadlock,operating-systems-for-gate
8,CPU and I/O scheduling,operating-systems-for-gate
8,Memory management and virtual memory,operating-systems-for-gate memory-hierarchy-and-cache-mapping
8,File systems,operating-systems-for-gate
9,ER-model,databases-and-warehousing
9,"Relational model: relational algebra, tuple calculus, SQL",databases-and-warehousing
9,"Integrity constraints, normal forms",databases-and-warehousing
9,"File organization, indexing (e.g., B and B+ trees)",databases-and-warehousing
9,Transactions and concurrency control,databases-and-warehousing
10,Principles of Layering,computer-networks-for-gate-2027
10,"Basics of switching (circuit, packet and virtual circuit) and performance metrics",computer-networks-for-gate-2027
10,"Data link layer: error detection, Medium Access Control, Ethernet",computer-networks-for-gate-2027
10,Distance vector and link state routing,computer-networks-for-gate-2027
10,"IPv4 - Fragmentation, CIDR Notation, Network Address Translation",computer-networks-for-gate-2027
10,"TCP- flow control and congestion control, socket API",computer-networks-for-gate-2027
10,DNS and HTTP,computer-networks-for-gate-2027

DA · plan/da.csv

section,clause,lesson
1,Counting (permutation and combinations),graphs-and-combinatorics probability-and-statistics
1,"probability axioms, Sample space, events, independent events, mutually exclusive events, marginal, conditional and joint probability, Bayes Theorem",probability-and-statistics
1,"conditional expectation and variance, mean, median, mode and standard deviation, correlation, and covariance",probability-and-statistics
1,"random variables, discrete random variables and probability mass functions, uniform, Bernoulli, binomial distribution",probability-and-statistics
1,"Continuous random variables and probability distribution function, uniform, exponential, Poisson, normal, standard normal",probability-and-statistics
1,"t-distribution, chi-squared distributions, cumulative distribution function, Conditional PDF",probability-and-statistics
1,"Central limit theorem, confidence interval, z-test, t-test, chi-squared test",probability-and-statistics
2,"Vector space, subspaces, linear dependence and independence of vectors",linear-algebra-for-da
2,"matrices, projection matrix, orthogonal matrix, idempotent matrix, partition matrix and their properties",linear-algebra-for-da
2,quadratic forms,linear-algebra-for-da
2,systems of linear equations and solutions; Gaussian elimination,linear-algebra-core
2,"eigenvalues and eigenvectors, determinant, rank, nullity",linear-algebra-core linear-algebra-for-da
2,projections,linear-algebra-for-da
2,LU decomposition,linear-algebra-core
2,singular value decomposition,linear-algebra-for-da clustering-and-pca
3,"Functions of a single variable, limit, continuity and differentiability",calculus-and-optimisation
3,Taylor series,calculus-and-optimisation
3,"maxima and minima, optimization involving a single variable",calculus-and-optimisation
4,Programming in Python,python-and-dsa-for-da
4,"basic data structures: stacks, queues, linked lists, trees, hash tables",python-and-dsa-for-da
4,Search algorithms: linear search and binary search,complexity-searching-sorting-hashing python-and-dsa-for-da
4,"basic sorting algorithms: selection sort, bubble sort and insertion sort",complexity-searching-sorting-hashing python-and-dsa-for-da
4,"divide and conquer: mergesort, quicksort",complexity-searching-sorting-hashing python-and-dsa-for-da
4,introduction to graph theory; basic graph algorithms: traversals and shortest path,algorithm-design-and-graph-algorithms python-and-dsa-for-da
5,"ER-model, relational model: relational algebra, tuple calculus, SQL, integrity constraints, normal form, file organization, indexing",databases-and-warehousing
5,data types,databases-and-warehousing
5,"data transformation such as normalization, discretization, sampling, compression",databases-and-warehousing
5,"data warehouse modelling: schema for multidimensional data models, concept hierarchies",databases-and-warehousing
5,measures: categorization and computations,databases-and-warehousing
6,"regression and classification problems, simple linear regression, multiple linear regression, ridge regression, logistic regression",regression-and-model-validation
6,"k-nearest neighbour, naive Bayes classifier, linear discriminant analysis, support vector machine, decision trees",classifiers-and-neural-networks
6,"bias-variance trade-off, cross-validation methods such as leave-one-out (LOO) cross-validation, k-folds cross-validation",regression-and-model-validation
6,"multi-layer perceptron, feed-forward neural network",classifiers-and-neural-networks
6,"clustering algorithms, k-means/k-medoid, hierarchical clustering, top-down, bottom-up: single-linkage, multiple-linkage",clustering-and-pca
6,"dimensionality reduction, principal component analysis",clustering-and-pca
7,"Search: informed, uninformed, adversarial",ai-search
7,"logic, propositional, predicate",ai-logic-and-probabilistic-inference
7,"reasoning under uncertainty topics - conditional independence representation, exact inference through variable elimination, and approximate inference through sampling",ai-logic-and-probabilistic-inference

GA · plan/ga.csv

section,clause,lesson
1,"Basic English grammar: tenses, articles, adjectives, prepositions, conjunctions, verb-noun agreement, and other parts of speech",general-aptitude-for-gate
1,"Basic vocabulary: words, idioms, and phrases in context",general-aptitude-for-gate
1,"Reading and comprehension, Narrative sequencing",general-aptitude-for-gate
2,"Data interpretation: data graphs (bar graphs, pie charts, and other graphs representing data), 2-and 3-dimensional plots, maps, and tables",general-aptitude-for-gate
2,"Numerical computation and estimation: ratios, percentages, powers, exponents and logarithms, permutations and combinations, and series",general-aptitude-for-gate
2,"Mensuration and geometry, Elementary statistics and probability",general-aptitude-for-gate
3,"Logic: deduction and induction, Analogy, Numerical relations and reasoning",general-aptitude-for-gate
4,"Transformation of shapes: translation, rotation, scaling, mirroring, assembling, and grouping paper folding, cutting, and patterns in 2 and 3 dimensions",general-aptitude-for-gate

Each row is one clause, numbered by its place in its section: the second row of section 6 is clause 6.2. Your checklist is the file of your paper plus the GA file: 63 clauses for CS and 46 for DA. A candidate who sits both papers keeps all 101: the two subject lists overlap in places, such as databases and linear algebra, but each paper words those topics its own way, so keep both versions and study them together.

For each clause keep three marks: learnt (you have worked through its lesson), practised (you have done a timed set on it) and revised (you have gone back to the problems you missed, after a gap). Step through one clause of section 3, from its line in the syllabus to its third mark:

Interactive · stage by stage One clause, from the syllabus to its three marks Step through clause 3.3 of the CS syllabus, from its line in section 3 to the three marks that say it is done.

The drawing shows the whole scene; its 7 steps are listed below.

Every step as text

The section. Section 3 of the CS syllabus, computer organisation and architecture, names six items in its own words. For 2027 one of them is new, the design of hardwired and microprogrammed control units.
The clause. Each item becomes a clause, numbered by its place in the section. "Design of control unit – hardwired and microprogrammed" is the third item of section 3, so it is clause 3.3.
Its lesson. The checklist file gives every clause the lesson of this track that teaches it. Clause 3.3 points to the lesson on the instruction set, the ALU and the control unit.
Its week. The plan gives the clause one week to start in. In the 18-week plan later in this lesson, clause 3.3 starts in week 3, with 3.2 and 3.4, inside the 26.2 hours that computer organisation gets.
Learnt. The first mark, learnt, means you have worked through the clause's lesson and its examples.
Practised. The second mark, practised, means you have done a timed set on the clause at the paper's pace.
Revised. The third mark, revised, means you have gone back to the problems of this clause that you missed, after a gap. Preparation is complete when all 63 clauses of a CS checklist carry all three marks.

A plan is complete when every clause has a week; preparation is complete when every clause has all three marks.

Key idea

Plan by clauses: every clause of the official syllabus gets a week, a lesson and three marks, so a clause the plan leaves out shows up as a gap, and a topic the syllabus dropped never takes a week.

Checkpoint

Check: The syllabus as a checklist of clauses

Question 1 of 2 How many clauses does a CS candidate's checklist hold, General Aptitude included?
Type a number.
Your answer clauses

A hint

The checklist is the file of your paper plus the GA file.

Show the answer: Question 1 of 2

Answer: 63 clauses

The CS syllabus has 55 clauses in its 10 sections and General Aptitude adds 8, so a CS checklist holds 55 + 8 = 63 clauses. A DA candidate's holds 38 + 8 = 46.
Question 2 of 2 A timetable from an earlier year gives a week to UDP, SMTP and FTP. What does a checklist built from the 2027 CS syllabus do with that week?
Choose one answer.

Keeps it, because networks carries fixed marks in the paper Gives it to clauses the 2027 syllabus names, because no clause names those topics Keeps it, because earlier papers asked about those topics Drops the whole networks section from the plan

Show the answer: Question 2 of 2

Answer: Gives it to clauses the 2027 syllabus names, because no clause names those topics

The checklist is built from the 2027 PDF, so its clauses are exactly what the 2027 papers may ask. Topics that only an earlier syllabus named get no clause and no week, while the seven networks clauses that remain each get theirs.

Only General Aptitude and CS mathematics have fixed marks

The Information Brochure fixes only a few numbers. Each paper carries 100 marks over 65 questions. General Aptitude takes 15 of those marks with ten questions, half of them worth 1 mark and half worth 2. Of the 85 subject marks of the CS paper, engineering mathematics takes 13. Nothing official divides the other 72 CS marks, or the 85 subject marks of DA, among the sections. A table of marks per subject is somebody’s count of earlier papers, and nothing stops the next paper from moving marks between sections.

What you can do with the fixed totals is divide them by the clauses they cover. That shows where an hour of study reaches the most marks on average:

Part of the paper	Clauses	Marks the brochure fixes	Marks per clause, if spread evenly
General Aptitude, every paper	8	15	1.9
CS section 1, engineering mathematics	8	13	1.6
CS sections 2 to 10	47	72 together	1.5
DA sections 1 to 7	38	85 together	2.2

Averages hide differences inside each row, but two conclusions hold. General Aptitude is worth more per clause than the CS sections, so it deserves a slot in every week rather than a cram in the last fortnight. And engineering mathematics is the one CS section whose marks are fixed, so it never drops out of a CS plan.

Key idea

Only General Aptitude’s 15 marks and, in CS, engineering mathematics’ 13 are fixed. Per clause, General Aptitude is worth more than the CS sections, so both of those parts get a slot in every week.

Checkpoint

Check: The marks the brochure fixes

One question General Aptitude carries 15 fixed marks over its 8 clauses. How many marks per clause is that, spread evenly, to one decimal place?
Type a number.
Your answer marks a clause

Show the answer: One question

Answer: 1.9 marks a clause (anything from 1.85 to 1.95 counts)

15 ÷ 8 = 1.875, about 1.9 marks a clause, more than the 1.5 of CS sections 2 to 10 (72 marks over 47 clauses). That is why General Aptitude gets a slot in every week of the plan.

A diagnostic decides how many hours each section gets

Hours should go where you are weak, so measure that first. Give each main section a short diagnostic, either just before its turn in the plan or all of them in the first week: about ten exam-level questions you have not seen before, in 30 to 40 minutes, scored with GATE’s marking. The questions of one section from an older official paper work well, as does any set of exam-level questions on that section that you have not used yet.

The plan turns each score into a need:

Below 40 %: learn. The section gets its full share of hours, and you start from its lesson.
From 40 % to 69 %: practise. About two thirds of a full share (the program below uses 0.65): you know the ideas and need timed sets.
70 % or more: maintain. About a third of a share (0.35), enough to keep it sharp with timed sets and spaced reviews.

A section’s hours are then in proportion to its clauses times that share. Step through three sections of the plan below, one for each need, and watch the score set the hours:

Interactive · step by step Three sections, three needs Step through three sections of the 18-week plan. Each diagnostic score picks a need, and the need sets the share of time each clause gets.

The drawing shows the whole scene; its 5 steps are listed below.

Every step as text

Three needs. A diagnostic of about ten unseen exam-level questions, scored with GATE's marking, puts each main section in one of three needs. The need decides what share of a full learning time each of its clauses gets.
25 % means learn. Theory of computation scored 25 %, below 40 %, so it is learnt from its lesson with a full share for each of its 4 clauses. The plan gives it 17.4 hours, about 4.4 a clause, and studies it first.
55 % means practise. Digital logic scored 55 %, so it needs practice. Each of its 3 clauses gets 0.65 of a full share, 8.5 hours in all, spent on timed sets rather than on learning the ideas again.
75 % means maintain. Programming and data structures scored 75 %, so it is maintained with 0.35 of a share for each of its 5 clauses. Its 7.6 hours, about an hour and a half a clause, are enough for timed sets and spaced reviews.
No score yet. A section with no diagnostic yet counts as learn until it has one. The cut-offs and the shares are starting points; after two weeks, move them to match the hours your clauses really took.

These cut-offs are MySmartCoPilot’s starting points, not research findings. After two weeks, compare the hours a clause really took with the hours the plan gave it, and move the cut-offs or the shares to match. A section with no diagnostic yet counts as “learn” until it has one.

Checkpoint

Check: Hours from a diagnostic score

Question 1 of 2 You score 35 % on a diagnostic in compiler design. Under the lesson's starting rule, what share of a full learning time does each of its clauses get?
Choose one answer.

None until the mixed tests begin All of it, because 35 % is below 40 % and the section must be learnt About a third, because it only needs to be kept up About two thirds, because it needs practice

Show the answer: Question 1 of 2

Answer: All of it, because 35 % is below 40 % and the section must be learnt

Below 40 % the section is learnt from the start and gets its full share; from 40 % to 69 % it gets about two thirds; from 70 % about a third. The cut-offs are starting points to move once your first weeks show how fast you really cover a clause.
Question 2 of 2 Compiler design (35 %) and databases (50 %) both have 5 clauses, and the plan gives compiler design 21.8 hours. About how many hours does it give databases?
Type a number.
Your answer hours

A hint

With the same number of clauses, their hours differ only by their shares, a full share against 0.65 of one.

Show the answer: Question 2 of 2

Answer: 14.2 hours (anything from 13.8 to 14.6 counts)

With 5 clauses each, the hours are in the ratio of the shares, 1 to 0.65, so databases gets 21.8 × 0.65 ≈ 14.2 hours, the figure the program prints. At exactly two thirds it would be about 14.5.

Plan on four fifths of your hours, backwards from the exam

Count the weeks from today to the first exam day of GATE 2027. The exams run over three weekends in February, and the day of your own paper is announced later with the timetable, so plan to the first day. Multiply the weeks by the hours you expect to study in a normal week, then by 0.8, the slippage factor: The share of the study hours you expect that a plan counts on. MySmartCoPilot's rule of thumb is 0.8, which leaves a fifth for illness, travel and weeks that go wrong.. That factor is a MySmartCoPilot rule of thumb, not a measured constant: a plan that counts on every hour you hope for runs out in its last month, which is exactly where the mocks are.

Date Calculator Count the days from today to the first exam day, then divide by 7 for the weeks left.

Then lay the weeks out backwards from the exam:

The last 3 to 4 weeks: one full-length mock a week under exam conditions, with the rest of the time spent on revision from your notes and on the problems you missed.
The 2 to 3 weeks before them: timed tests that mix every section, so that you practise switching topics the way the paper does.
Every week before that: learning and practising one main section at a time, with a small weekly strand of General Aptitude and, in CS, engineering mathematics, so that those clauses move forward in every week.

Put your weakest sections early, so that the mixed tests can come back to them. A section that builds on another waits for it: digital logic before computer organisation, programming and data structures before algorithms, theory of computation before compiler design, and in DA, probability and linear algebra before machine learning.

Walk through the phases of the plan in the next section, 18 weeks of 22 hours, with the hours each phase gets:

Timeline · 5 events in order An 18-week plan, phase by phase, with its hours Walk through the plan of this lesson in time order. It was laid out backwards from the exam, and each phase says how many of the 316.8 usable hours it gets.

Before week 1

Count the usable hours

18 weeks × 22 hours × 0.8 = 316.8 hours, 17.6 a week. The fifth of the hours you hope for that the plan does not count on is left for illness, travel and bad weeks.
Weeks 1 to 11

Learn and practise one section at a time learning

193.6 hours. 149.6 of them go to the nine main sections, weakest first but never before a section they build on, and 44 to a weekly strand of 4 hours for General Aptitude and engineering mathematics.
Weeks 12 to 14

Timed tests that mix every section mixed tests

52.8 hours of timed sets that mix the sections, the weakest twice a week, so that you practise switching topics the way the paper does.
Weeks 15 to 18

One full-length mock a week mocks

70.4 hours. Each week holds one mock under exam conditions, and the rest of the time goes to revision from one-page notes and to the problems you missed.
First exam day

The plan ends at the first exam day

The exams run over three weekends in February, and the day of your own paper is announced later with the timetable, so the plan counts the weeks to the first exam day.

Key idea

Count the weeks to the first exam day, plan on 80 % of the hours you expect, and lay the phases out backwards: the mock weeks last, the mixed tests before them, and learning in every week before that.

Checkpoint

Check: Usable hours and the phases of a plan

Question 1 of 2 You expect to study 15 hours a week for the 20 weeks left before your exam. With the slippage factor of 0.8, how many hours should your plan count on?
Type a number.
Your answer hours

Show the answer: Question 1 of 2

Answer: 240 hours

20 weeks × 15 hours = 300 hours expected, and 0.8 × 300 = 240 hours to plan with. The other 60 hours are the weeks that go wrong: an illness, a family event, a semester exam. A plan built on all 300 runs out in its last month, which is where the mocks are.
Question 2 of 2 You have 12 weeks left and expect 20 hours a week. With the lesson's phases, 4 weeks of mocks and revision and 3 of mixed tests, how many usable hours do the learning weeks hold?
Type a number.
Your answer hours

A hint

Usable hours a week first (20 × 0.8), then the weeks left for learning (12 − 4 − 3).

Show the answer: Question 2 of 2

Answer: 80 hours

20 × 0.8 = 16 usable hours a week, and 12 − 4 − 3 = 5 learning weeks, so 5 × 16 = 80 hours. The mixed tests get 48 and the mock weeks 64: a short run-up squeezes the learning weeks hardest.

A program shares out the hours and checks every clause

Here is the whole method as one program, for an invented CS candidate with 18 weeks left, 22 hours a week and the diagnostic scores at the top of the file. It reads the clause files, splits the usable hours into the three phases, gives each main section hours in proportion to its clauses times its need, orders the sections, fills the learning weeks and checks the result:

An 18-week CS plan from the clause checklist Python · plan/plan.py

"""A week-by-week GATE plan built from the official syllabus clauses in cs.csv, da.csv and ga.csv."""
import csv

# ---- Your numbers: edit them and run again ---------------------------------------------------------------------
PAPER = "CS"            # "CS" or "DA"
WEEKS_LEFT = 18         # whole weeks until your first exam day
HOURS_PER_WEEK = 22     # the hours you expect to study in a normal week
SLIPPAGE = 0.8          # plan on 80 % of them: illness, travel and bad weeks happen
FINAL_WEEKS = 4         # full-length mocks and revision
MIXED_WEEKS = 3         # timed tests that mix every section
STRAND_HOURS = {"CS": 4, "DA": 2}   # each learning week: General Aptitude, and engineering mathematics in CS
DIAGNOSTIC = {                      # % scored in a short diagnostic of each main section
    "CS": {2: 55, 3: 30, 4: 75, 5: 45, 6: 25, 7: 35, 8: 60, 9: 50, 10: 40},
    "DA": {1: 45, 2: 35, 3: 60, 4: 80, 5: 50, 6: 30, 7: 20},
}

NAMES = {
    "CS": {1: "Engineering mathematics", 2: "Digital logic", 3: "Computer organisation", 4: "Programming and DS",
           5: "Algorithms", 6: "Theory of computation", 7: "Compiler design", 8: "Operating systems",
           9: "Databases", 10: "Computer networks"},
    "DA": {1: "Probability and statistics", 2: "Linear algebra", 3: "Calculus", 4: "Programming, DS, algorithms",
           5: "Databases, warehousing", 6: "Machine learning", 7: "AI"},
    "GA": {1: "Verbal", 2: "Quantitative", 3: "Analytical", 4: "Spatial"},
}
STRAND = {"CS": [1], "DA": []}                                     # sections that join GA in the weekly strand
BEFORE = {"CS": [(2, 3), (4, 5), (6, 7)], "DA": [(1, 6), (2, 6)]}   # (a, b): learn section a before section b


def need(score):
    """The share of a section's full learning time that its diagnostic score says it needs."""
    if score < 40:
        return "learn", 1.0
    if score < 70:
        return "practise", 0.65
    return "maintain", 0.35


def read(paper):
    """Clauses as (paper, section, number in section, text), numbered in syllabus order."""
    rows, count = [], {}
    with open(f"{paper.lower()}.csv", newline="", encoding="utf-8") as f:
        for r in csv.DictReader(f):
            s = int(r["section"])
            count[s] = count.get(s, 0) + 1
            rows.append((paper, s, count[s], r["clause"]))
    return rows


def section_order(sections, before, score):
    """Weakest first, but never a section before one it builds on: a weak section pulls its prerequisite forward."""
    def weakest(s):
        return min([score[s]] + [weakest(b) for a, b in before if a == s and b in sections])

    order, left = [], sorted(sections)
    while left:
        ready = [s for s in left if all(a in order for a, b in before if b == s and a in sections)]
        pick = min(ready, key=lambda s: (weakest(s), score[s], s))
        order.append(pick)
        left.remove(pick)
    return order


def weeks_of(items, per_week):
    """Fill per_week hours a week, in order: the hours each week gives each section, and the week each clause starts."""
    hours, starts, done = {}, {}, 0.0
    for clause, h in items:
        starts[clause] = int(done / per_week + 1e-9) + 1
        while h > 1e-9:
            week = int(done / per_week + 1e-9) + 1
            part = min(h, week * per_week - done)
            hours.setdefault(week, {})
            hours[week][clause[:2]] = hours[week].get(clause[:2], 0) + part
            done, h = done + part, h - part
    return hours, starts


def ids(clauses):
    """Clause numbers: 6.2 is the second clause of section 6; the weekly strand names its paper (CS 1.2, GA 1.1)."""
    return ", ".join(f"{p} {s}.{n}" if p == "GA" or s in STRAND[PAPER] else f"{s}.{n}" for p, s, n, _ in clauses)


score = DIAGNOSTIC[PAPER]
clauses = read(PAPER) + read("GA")
usable = HOURS_PER_WEEK * SLIPPAGE
learn_weeks = WEEKS_LEFT - FINAL_WEEKS - MIXED_WEEKS
strand_hours = STRAND_HOURS[PAPER]
main_hours = learn_weeks * (usable - strand_hours)
print(f"Usable: {WEEKS_LEFT} weeks x {HOURS_PER_WEEK} h x {SLIPPAGE} = {WEEKS_LEFT * usable:.1f} h ({usable:.1f} h a week)")
print(f"  learning, weeks 1-{learn_weeks}: {learn_weeks * usable:.1f} h = {main_hours:.1f} h for the main sections"
      f" + {learn_weeks * strand_hours:.1f} h for the weekly strand")
print(f"  mixed tests, weeks {learn_weeks + 1}-{learn_weeks + MIXED_WEEKS}: {MIXED_WEEKS * usable:.1f} h")
print(f"  mocks and revision, weeks {learn_weeks + MIXED_WEEKS + 1}-{WEEKS_LEFT}: {FINAL_WEEKS * usable:.1f} h")

main = [c for c in clauses if c[0] == PAPER and c[1] not in STRAND[PAPER]]
strand_a = [c for c in clauses if c[0] == PAPER and c[1] in STRAND[PAPER]]
strand_b = [c for c in clauses if c[0] == "GA"]
sections = sorted({c[1] for c in main})
size = {s: sum(1 for c in main if c[1] == s) for s in sections}
weight = {s: size[s] * need(score[s])[1] for s in sections}
hours = {s: main_hours * weight[s] / sum(weight.values()) for s in sections}
order = section_order(sections, BEFORE[PAPER], score)

print("\nOrder  section                      score  need      clauses  hours")
for i, s in enumerate(order, 1):
    print(f"{i:5}  {NAMES[PAPER][s]:28} {score[s]:3} %  {need(score[s])[0]:9} {size[s]:5} {hours[s]:8.1f}")

main_items = [(c, hours[c[1]] / size[c[1]]) for s in order for c in main if c[1] == s]
strand = [c for pair in zip(strand_a + [None] * len(strand_b), strand_b + [None] * len(strand_a)) for c in pair if c]
strand_items = [(c, learn_weeks * strand_hours / len(strand)) for c in strand]
main_weeks, main_starts = weeks_of(main_items, usable - strand_hours)
side_weeks, side_starts = weeks_of(strand_items, strand_hours)

print()
for w in range(1, learn_weeks + 1):
    rows = [(NAMES[p][s], h, [c for c in main if c[1] == s and main_starts[c] == w]) for (p, s), h in main_weeks[w].items()]
    rows.append(("weekly strand", sum(side_weeks[w].values()), [c for c in strand if side_starts[c] == w]))
    for i, (name, h, new) in enumerate(rows):
        label = f"Week {w}" if i == 0 else ""
        print(f"{label:8} {name:28} {h:5.1f} h" + (f"  starts {ids(new)}" if new else ""))
print(f"Weeks {learn_weeks + 1}-{learn_weeks + MIXED_WEEKS}: timed sets that mix every section, the weakest twice a week")
print(f"Weeks {learn_weeks + MIXED_WEEKS + 1}-{WEEKS_LEFT}: one full-length mock a week, revision from one-page notes")

# The plan checks itself: every clause in exactly one week, inside the learning weeks, in the order the rules allow.
starts = {**main_starts, **side_starts}
assert sorted(starts) == sorted(clauses), "a clause is missing or placed twice"
assert max(starts.values()) <= learn_weeks, "the clauses do not fit in the learning weeks"
assert all(order.index(a) < order.index(b) for a, b in BEFORE[PAPER]), "a section comes before one it builds on"
print(f"\nCheck: all {len(clauses)} clauses ({PAPER} and GA) placed once, inside weeks 1-{learn_weeks}, order rules kept")

Output

Usable: 18 weeks x 22 h x 0.8 = 316.8 h (17.6 h a week)
  learning, weeks 1-11: 193.6 h = 149.6 h for the main sections + 44.0 h for the weekly strand
  mixed tests, weeks 12-14: 52.8 h
  mocks and revision, weeks 15-18: 70.4 h

Order  section                      score  need      clauses  hours
    1  Theory of computation         25 %  learn         4     17.4
    2  Digital logic                 55 %  practise      3      8.5
    3  Computer organisation         30 %  learn         6     26.2
    4  Compiler design               35 %  learn         5     21.8
    5  Computer networks             40 %  practise      7     19.8
    6  Programming and DS            75 %  maintain      5      7.6
    7  Algorithms                    45 %  practise      4     11.3
    8  Databases                     50 %  practise      5     14.2
    9  Operating systems             60 %  practise      8     22.7

Week 1   Theory of computation         13.6 h  starts 6.1, 6.2, 6.3, 6.4
         weekly strand                  4.0 h  starts CS 1.1, GA 1.1
Week 2   Theory of computation          3.8 h
         Digital logic                  8.5 h  starts 2.1, 2.2, 2.3
         Computer organisation          1.2 h  starts 3.1
         weekly strand                  4.0 h  starts CS 1.2
Week 3   Computer organisation         13.6 h  starts 3.2, 3.3, 3.4
         weekly strand                  4.0 h  starts GA 1.2, CS 1.3
Week 4   Computer organisation         11.3 h  starts 3.5, 3.6
         Compiler design                2.3 h  starts 7.1
         weekly strand                  4.0 h  starts GA 1.3
Week 5   Compiler design               13.6 h  starts 7.2, 7.3, 7.4
         weekly strand                  4.0 h  starts CS 1.4, GA 2.1
Week 6   Compiler design                5.9 h  starts 7.5
         Computer networks              7.7 h  starts 10.1, 10.2, 10.3
         weekly strand                  4.0 h  starts CS 1.5
Week 7   Computer networks             12.2 h  starts 10.4, 10.5, 10.6, 10.7
         Programming and DS             1.4 h  starts 4.1
         weekly strand                  4.0 h  starts GA 2.2, CS 1.6
Week 8   Programming and DS             6.2 h  starts 4.2, 4.3, 4.4, 4.5
         Algorithms                     7.4 h  starts 5.1, 5.2, 5.3
         weekly strand                  4.0 h  starts GA 2.3
Week 9   Algorithms                     3.9 h  starts 5.4
         Databases                      9.7 h  starts 9.1, 9.2, 9.3, 9.4
         weekly strand                  4.0 h  starts CS 1.7, GA 3.1
Week 10  Databases                      4.5 h  starts 9.5
         Operating systems              9.1 h  starts 8.1, 8.2, 8.3, 8.4
         weekly strand                  4.0 h  starts CS 1.8
Week 11  Operating systems             13.6 h  starts 8.5, 8.6, 8.7, 8.8
         weekly strand                  4.0 h  starts GA 4.1
Weeks 12-14: timed sets that mix every section, the weakest twice a week
Weeks 15-18: one full-length mock a week, revision from one-page notes

Check: all 63 clauses (CS and GA) placed once, inside weeks 1-11, order rules kept

Recorded with Python 3.14.8 on macOS 26 arm64. To run it yourself: mise exec python@3.14.8 -- python3 plan.py

Read the output in three parts:

The budget. 18 weeks × 22 hours × 0.8 gives 316.8 hours, 17.6 a week. The last four weeks keep 70.4 hours for mocks and revision and the three before them 52.8 hours for mixed tests. That leaves 149.6 hours for the nine main sections and 44 hours for the weekly strand.
The order. Theory of computation comes first because 25 % is the weakest score. Digital logic comes second although its 55 % would rank it in the middle: computer organisation, at 30 %, builds on it and pulls it forward. Programming and data structures, at 75 %, gets 7.6 hours for its 5 clauses, about an hour and a half each, which is enough for timed sets but not for learning them again. Operating systems still gets 22.7 hours at 60 % because it has the most clauses, 8.
The weeks. Each line gives a section’s hours in that week and the clauses that start there. A clause may run past the end of a week, but it starts in exactly one, and the last line confirms that all 63 clauses start once, inside the 11 learning weeks, with every order rule kept.

Make the plan yours

Press Edit and set your weeks, your hours and your scores, or PAPER = "DA", which plans the 38 DA clauses with a General Aptitude strand of 2 hours a week, then run it again. The last three lines of the program check the plan it built before it prints the final line, so a change that leaves a clause out stops with an error instead of printing a plan with a hole in it.

Checkpoint

Check: Reading the plan the program builds

Question 1 of 2 In the lesson's plan, computer organisation scored 30 % and digital logic 55 %, yet digital logic is studied first. Why?
Choose one answer.

Digital logic has more clauses Digital logic carries more marks in the official pattern Computer organisation builds on digital logic, so the weak section pulls the section it needs forward Sections are always studied in the order of the syllabus

Show the answer: Question 1 of 2

Answer: Computer organisation builds on digital logic, so the weak section pulls the section it needs forward

The plan studies the weakest sections first, but never before what they build on: ALU and control-unit design use the circuits and number representation of digital logic. Digital logic has 3 clauses and computer organisation 6, and the brochure gives neither a mark count.
Question 2 of 2 The plan keeps 4 hours of every learning week for the weekly strand of General Aptitude and engineering mathematics. How many hours is that over weeks 1 to 11?
Type a number.
Your answer hours

Show the answer: Question 2 of 2

Answer: 44 hours

11 learning weeks × 4 hours = 44 hours, as the first lines of the output say: 193.6 learning hours are 149.6 for the main sections and 44.0 for the weekly strand.

Keep the plan honest every week

A plan is a guess made on its first day, and the weekly review corrects it. Once a week, on the same day, spend half an hour on four questions:

Hours. How many hours did you really study, against the plan’s? If you keep falling short, the slippage factor is too generous: lower it and run the plan again, rather than promising yourself longer weeks later.
Clauses. Which clauses did not start? Move them into next week, not to the end of the plan, where they would collide with the mocks.
Scores. What did this week’s timed sets say? A section that moves from “learn” to “practise” frees hours for the others.
Mistakes. Which problem families did you miss, and when will you meet them again? The next lesson turns these into an error log with spaced reviews.

When you fall more than a week behind, plan again from today: set the weeks left, update the scores and run the program again. Take hours from the sections marked “maintain” first and from the mixed tests next, and keep the mock weeks, because they are the only full rehearsals of the paper you will get. Keep one block of every week clear of study as well, so that overruns have somewhere to go.

The whole plan fits in one picture with the review that steers it: each week the review moves unfinished clauses into the next learning week, never to the end of the plan.

An 18-week plan, laid out backwards from the exam

Text description of the diagram

The diagram is a column of boxes joined by arrows, from top to bottom:

1. Weeks 1 to 11: learn and practise one main section at a time, with General Aptitude and engineering mathematics a little every week. 2. Weeks 12 to 14: timed tests that mix every section. 3. Weeks 15 to 18: one full-length mock a week, and revision from one-page notes. 4. The first exam day.

A separate box, "Every week: compare planned and real hours, re-run the plan with the weeks left", has an arrow into the first phase labelled "moves unfinished clauses".

Two ways a plan breaks

One is planning with every hour you hope for, then cutting the mock month when weeks slip: plan on 80 % of them instead, and take hours from the sections marked “maintain” first. The other is studying the sections in syllabus order, which leaves whichever weak section comes last until the final weeks: study the weakest first, after the sections they build on.

Study Planner & Revision Timetable Turn the clauses into a day-by-day timetable with spaced reviews between the study sessions.

Key idea

Review the plan on the same day every week against the hours you really studied, move clauses that did not start into next week, and when you fall more than a week behind, plan again from today and keep the mock weeks.

Checkpoint

Check: The weekly review of a plan

Question 1 of 2 You fall two weeks behind in week 9. Which change follows the lesson's rules?
Choose one answer.

Drop two of the four mock weeks to catch up Leave General Aptitude out, since it is only 15 marks Keep the old timetable and study longer days in the final week Run the plan again with the weeks you have left, and take hours from the sections marked maintain first

Show the answer: Question 1 of 2

Answer: Run the plan again with the weeks you have left, and take hours from the sections marked maintain first

Planning again from the hours that are really left keeps every clause in the plan and shows what has to shrink. Sections you already score 70 % or more in lose least by being compressed. The mocks are the only rehearsal of the real paper, and 15 marks of aptitude are 15 % of the paper on 8 clauses.
Question 2 of 2 At the weekly review, clause 10.4 has not started. Where does it go?
Choose one answer.

To the end of the plan Into the mixed tests Out of the plan, since one clause is a small part of the paper Into next week

Show the answer: Question 2 of 2

Answer: Into next week

Clauses that did not start move into next week, not to the end of the plan, where they would collide with the mocks. If too many pile up, plan again from today.

Practise: check a plan made by hand, then the whole lesson

The program above refuses a plan with a hole in it, and a plan written by hand needs the same guard. Write it in Python: every clause in exactly one week, and no week over its hours. The sample tests run in your browser:

Exercise · Easy · Python

Check that a study plan covers every clause once

A plan made by hand goes wrong in three quiet ways: a clause of the syllabus never gets a week, a clause gets two, or a week holds more hours than you have. Write plan_problems(plan, clauses, weekly_hours) in check.py so that it finds all three.

clauses is the checklist: a list of clause numbers such as ["CS 6.1", "CS 6.2", "GA 1.1"].
plan is a dictionary from a week number to the list of (clause, hours) pairs planned in that week, such as {1: [("CS 6.1", 4.5), ("GA 1.1", 2.0)], 2: [("CS 6.2", 5.0)]}.
weekly_hours is the most hours a week may hold.

Return a list of problems, in this order:

("missing", clause) for every clause of the checklist that no week plans, in checklist order;
("twice", clause) for every clause planned more than once, listed once, in checklist order;
("over", week) for every week whose hours add up to more than weekly_hours, in week order.

A plan without problems gives []. Hours are decimals, so allow for rounding: a week of exactly weekly_hours is fine. The sample tests use clauses of the GATE 2027 CS and GA syllabi, import the function from check.py and run in your browser.

Starter code · check.py

def plan_problems(plan, clauses, weekly_hours):
    """Missing clauses, clauses planned twice and overfull weeks of a study plan, in that order."""
    # Replace this line with your code.
    return None

The sample tests · test_check.py

from check import plan_problems

CHECKLIST = ["CS 6.1", "CS 6.2", "CS 6.3", "CS 6.4", "GA 1.1", "GA 1.2"]


def test_good_plan():
    """a plan that covers every clause once, within the hours, has no problems"""
    plan = {
        1: [("CS 6.1", 4.5), ("CS 6.2", 4.5), ("GA 1.1", 2.0)],
        2: [("CS 6.3", 4.5), ("CS 6.4", 4.5), ("GA 1.2", 2.0)],
    }
    assert plan_problems(plan, CHECKLIST, 11.0) == []


def test_missing():
    """clauses that no week plans are missing, in checklist order"""
    plan = {1: [("CS 6.2", 4.0), ("CS 6.1", 4.0)], 2: [("CS 6.4", 4.0)]}
    assert plan_problems(plan, CHECKLIST, 10.0) == [("missing", "CS 6.3"), ("missing", "GA 1.1"), ("missing", "GA 1.2")]


def test_twice():
    """a clause planned in two weeks, or twice in one, is reported once"""
    plan = {
        1: [("CS 6.1", 3.0), ("CS 6.2", 3.0), ("CS 6.1", 1.0)],
        2: [("CS 6.3", 3.0), ("CS 6.4", 3.0), ("GA 1.1", 2.0), ("GA 1.2", 2.0)],
        3: [("CS 6.1", 2.0)],
    }
    assert plan_problems(plan, CHECKLIST, 10.0) == [("twice", "CS 6.1")]


def test_over():
    """a week with more hours than the limit is overfull; exactly the limit is fine"""
    plan = {
        3: [("CS 6.3", 6.0), ("CS 6.4", 6.0)],
        1: [("CS 6.1", 6.3), ("CS 6.2", 4.7)],
        2: [("GA 1.1", 0.1), ("GA 1.2", 0.2)],
    }
    assert plan_problems(plan, CHECKLIST, 11.0) == [("over", 3)]


def test_order():
    """missing, then twice, then over, each in its own order"""
    plan = {
        2: [("CS 6.4", 9.0), ("GA 1.2", 3.0)],
        1: [("CS 6.2", 12.5), ("CS 6.4", 1.0)],
    }
    assert plan_problems(plan, CHECKLIST, 12.0) == [
        ("missing", "CS 6.1"),
        ("missing", "CS 6.3"),
        ("missing", "GA 1.1"),
        ("twice", "CS 6.4"),
        ("over", 1),
    ]

A hint

Count first: go through every week's pairs and add 1 to a counter for each clause (a dictionary from clause to count does it). Then walk the checklist once for the missing clauses (count 0) and once for the doubled ones (count 2 or more). For the weeks, compare sum(hours for _, hours in pairs) with weekly_hours + 1e-9 and walk the weeks in sorted(plan) order.

The sample tests run on this device, in your browser (Pyodide): nothing is sent to mysmartcopilot.com. The first run downloads Python (about 13.5 MB), which is kept for the next runs. A check in your browser is feedback for you, not proof that the code is right for every input.

The self-check below covers all six ideas of the lesson. It asks first about the one you have answered worst so far, moves up a level after each right answer, and brings back what you missed:

Interview questions

Why should a GATE study plan start from the official syllabus rather than a list of important topics? (warm-up)

The syllabus PDF is the only document that says what the paper may ask, and it changes: for 2027 the CS syllabus was rewritten in digital logic, computer organisation and computer networks. A list of important topics is someone’s count of earlier papers. It can miss a clause that is new, spend hours on one that was dropped, and it says nothing about your own weak sections. GATE also fixes no marks per section beyond General Aptitude’s 15 and, in CS, engineering mathematics’ 13, so nothing official ranks the other sections. Splitting the syllabus into clauses gives a checklist: every clause gets a week, a lesson and a practice source, and a plan that leaves one out is visibly incomplete. Diagnostic scores then decide how many hours each clause gets.

Key takeaways

The official syllabus is the only list of what GATE 2027 may ask. Split it into clauses: 55 for CS, 38 for DA and 8 for General Aptitude.
The brochure fixes only General Aptitude’s 15 marks and, in CS, engineering mathematics’ 13; marks per subject are counts of earlier papers, not rules.
Diagnose each section, then share the hours by clauses and need: learn below 40 %, practise up to 69 %, maintain from 70 %.
Plan with 80 % of the hours you expect, and lay the weeks out backwards: learning, then mixed tests, then a month of mocks and revision.
Study the weakest sections first, but never before the sections they build on.
Review the plan every week, plan again from today when you fall behind, and protect the mock weeks.

Terms in this lesson

diagnostic: A short timed set of about ten unseen exam-level questions on one section, scored with GATE marking, whose score decides how much study time the section gets in a plan.
slippage factor: The share of the study hours you expect that a plan counts on. MySmartCoPilot's rule of thumb is 0.8, which leaves a fifth for illness, travel and weeks that go wrong.
syllabus clause: One short item of a section of an official GATE syllabus, in the syllabus's own words, such as "Design of control unit – hardwired and microprogrammed": the unit a study plan gives a week, a lesson and three marks.

References

GATE 2027 syllabus: Computer Science and Information Technology (CS) (Indian Institute of Technology Madras (GATE 2027))
GATE 2027 syllabus: Data Science and Artificial Intelligence (DA) (Indian Institute of Technology Madras (GATE 2027))
GATE 2027 syllabus: General Aptitude (GA) (Indian Institute of Technology Madras (GATE 2027))
GATE 2026 syllabus: Computer Science and Information Technology (CS) (Indian Institute of Technology Guwahati (GATE 2026))
GATE 2027 Information Brochure (Indian Institute of Technology Madras (GATE 2027))
GATE 2027 question paper pattern (Indian Institute of Technology Madras (GATE 2027))
GATE 2027 important dates (Indian Institute of Technology Madras (GATE 2027))
csv: CSV file reading and writing (Python Software Foundation)

Report a problem with this lesson

Your country

A GATE study plan built from the official syllabus

What you will learn

Before you start

What you will learn

Before you start

Start from the clauses, not a timetable

Only General Aptitude and CS mathematics have fixed marks

A diagnostic decides how many hours each section gets

Plan on four fifths of your hours, backwards from the exam

A program shares out the hours and checks every clause

Keep the plan honest every week

Practise: check a plan made by hand, then the whole lesson

Check that a study plan covers every clause once

Results of the sample tests

Interview questions

Key takeaways

References

Related tools