GATE CS syllabus 2027

About the GATE CS paper

Computer Science & Information Technology is the most-attempted paper in GATE, and its character is different from most other papers in the exam. It is not a memorisation paper. Very few questions can be answered by recalling a formula. Instead the paper asks you to trace an algorithm, count something precisely, or reason about what a machine does, all under a clock that gives you roughly two and a half minutes per question.

That has a practical consequence. In CS, a subject you understand at 70 percent is worth close to nothing, because the questions are built to punish partial understanding. Depth in eight subjects beats shallow coverage of ten.

What each section of the syllabus actually covers

Engineering Mathematics

For CS this is really four separate subjects sharing one heading, and discrete mathematics is by far the largest of them.

Discrete mathematics covers propositional and first order logic, sets, relations, functions, partial orders and lattices, groups, and graph theory including connectivity, matching and colouring. Combinatorics adds counting, recurrence relations and generating functions. Linear algebra covers matrices, determinants, systems of linear equations, eigenvalues and eigenvectors, and LU decomposition. Calculus covers limits, continuity, differentiability, maxima and minima, the mean value theorem and integration. Probability covers random variables, the uniform, normal, exponential, Poisson and binomial distributions, conditional probability and Bayes’ theorem.

Discrete maths deserves special attention because it does double duty: it is examined directly, and it is the language that Algorithms and Theory of Computation are written in.

Digital Logic

Boolean algebra, combinational and sequential circuits, minimisation, number representations and computer arithmetic in both fixed and floating point. This is the smallest subject by marks but the fastest to finish, and floating point representation questions in particular tend to be mechanical once you have done a handful.

Computer Organization & Architecture

Machine instructions and addressing modes, the ALU, data path and control unit, instruction pipelining and pipeline hazards, the memory hierarchy including cache and main memory, and I/O interfacing through interrupts and DMA.

Two topics generate most of the questions here: pipelining, where you count stalls caused by hazards, and cache, where you compute average memory access time or hit ratios under a given mapping scheme. Both are numerical and both reward practice over theory.

Programming & Data Structures

Programming in C, recursion, arrays, stacks, queues, linked lists, trees, binary search trees, binary heaps and graphs.

Expect questions that hand you a short C function and ask what it returns, how many times a line executes, or what the pointer state is after a few operations. Reading code accurately under time pressure is a trainable skill and it is worth training deliberately.

Algorithms

Searching, sorting and hashing; asymptotic worst case time and space complexity; the three main design techniques of greedy, divide and conquer, and dynamic programming; graph traversals, minimum spanning trees and shortest paths.

Along with data structures this is the single largest scoring block in the paper. Questions often combine a design technique with a complexity analysis, so knowing that an algorithm exists is not enough. You need to be able to run it by hand on a small input and state its bound tightly.

Theory of Computation

Regular expressions and finite automata, context free grammars and pushdown automata, the regular and context free language classes, the pumping lemma, Turing machines and undecidability.

TOC is where careful candidates gain a reliable edge, because the questions are precise and the answers are not negotiable. The recurring themes are closure properties, deciding which class a given language belongs to, and separating decidable from undecidable problems.

Compiler Design

Lexical analysis, parsing, syntax directed translation, runtime environments, intermediate code generation, local optimisation, and data flow analyses such as constant propagation, liveness analysis and common subexpression elimination.

Parsing dominates. Constructing parse tables, spotting conflicts, and classifying a grammar by the parser that can handle it account for a large share of the questions asked here.

Operating Systems

System calls, processes and threads, inter-process communication, concurrency and synchronisation, deadlock, CPU and I/O scheduling, memory management and virtual memory, and file systems.

Synchronisation and virtual memory are the two heavyweights. Synchronisation questions usually give you a semaphore or monitor solution and ask whether it can deadlock or violate mutual exclusion. Virtual memory questions are arithmetic: page table sizes, TLB effects, effective access time, and page replacement counts under a given reference string.

Databases

The ER model, the relational model with relational algebra, tuple calculus and SQL, integrity constraints, normal forms, file organisation, indexing with B and B+ trees, and transactions with concurrency control.

Two clusters produce most questions. The first is functional dependencies: finding candidate keys, computing closures, and determining the highest normal form a relation satisfies. The second is transactions: testing a schedule for conflict serialisability, recoverability and cascadelessness. Both are procedural, which means both can be made almost automatic.

Computer Networks

Layering under the OSI and TCP/IP models, packet switching, the data link layer with framing, error detection, medium access control and Ethernet bridging, routing protocols including shortest path, flooding, distance vector and link state, fragmentation and IP addressing, IPv4 and CIDR notation, support protocols such as ARP, DHCP, ICMP and NAT, the transport layer with flow control, congestion control, UDP, TCP and sockets, and application layer protocols including DNS, SMTP, HTTP and FTP.

Networks rewards arithmetic accuracy more than breadth. Subnetting and CIDR, sliding window efficiency, and TCP throughput and congestion window calculations recur year after year.

Reading the weightage table

The table above is indicative, and the useful way to read it is by stability rather than by size. General Aptitude at 15 marks and Engineering Mathematics in the low teens are close to fixed every year, which means roughly 28 to 30 marks of the paper come from outside the core CS subjects. Candidates who treat those two as an afterthought are competing for the remaining 70 marks against people who are not.

Among the core subjects, Algorithms and Data Structures together form the largest and most reliable block. Operating Systems, Databases, Computer Networks and Theory of Computation sit in a similar band and move by a mark or two between years. Digital Logic and Compiler Design are the smallest, but they are also the quickest to prepare, so their marks per hour of study is often the best in the paper.

A preparation order that works

The syllabus has real dependencies, and studying it in the order printed on the official brochure ignores them. A sequence that respects the prerequisites:

1. Discrete mathematics first. It underpins Algorithms and Theory of Computation, so doing it early pays interest across the rest of the syllabus.
2. Programming and Data Structures, then Algorithms. You cannot analyse an algorithm you cannot implement.
3. Digital Logic, then Computer Organization. Number systems and sequential circuits are assumed knowledge in the architecture questions.
4. Theory of Computation, then Compiler Design. Grammars and automata are the machinery the parsing questions are built on.
5. Operating Systems, Databases and Computer Networks in any order. These three are largely independent of the rest and of each other, which makes them useful to slot into whatever time remains.
6. General Aptitude throughout, in short weekly sessions rather than one block.

How to use previous year papers

Do not start with them cold. Solve a subject’s previous year questions immediately after finishing that subject, while the material is still fresh, so you learn how that specific topic is actually asked. Only once the whole syllabus is covered should you switch to full papers under a strict three hour timer.

When you review, classify every mistake by cause rather than by topic: concept gap, calculation slip, misread question, or ran out of time. The four have completely different fixes, and most candidates discover that far fewer of their losses are concept gaps than they assumed.

Where candidates lose marks

• Negative marking on guesses. With one-third and two-thirds penalties on MCQs, a coin-flip guess has negative expected value. Eliminating two options first changes that, and knowing which situation you are in matters more than any individual question.
• Arithmetic under pressure. Cache, subnetting and pipelining questions are conceptually easy and lost to slips. Practise them to the point of boredom.
• Loose complexity bounds. A bound that is technically correct but not tight is still marked wrong.
• Skipping Numerical Answer Type questions. NAT questions carry no negative marking, so leaving one blank is a strictly worse choice than a considered attempt.
• Neglecting General Aptitude. It is the cheapest 15 marks in the paper and the section most often left to exam day.

General Aptitude, the section nobody should concede

General Aptitude is 15 marks in every GATE paper and needs no engineering background. It covers verbal ability, numerical reasoning, data interpretation and basic quantitative aptitude. Its questions are shorter than subject questions and its topics do not change.

Budget a fixed weekly slot for it from the beginning rather than a panic session in the last month. Fifteen marks reliably banked is a larger advantage than an extra subject studied badly.