What to study nextand why now

This topic is worth ~2.9 marks per paper, and recent questions include around 30 recent questions, split between 1-mark and 2-mark questions, with many NATs. You only need basic programming literacy to begin. It also prepares you for recursion, all DS, runtime environments, OS/COA examples. Study the types as GATE defines them, static lifetime, block scope, pointer arithmetic, array decay, switch fall-through, and evaluation order. You do not need to memorise a formula. Simulate the program. A useful way to solve these questions is to draw a memory diagram, rewrite a[i] as *(a+i), and think of static as “initialised once”. Be careful about missing break statements, local and file-scope variables with the same name, the false idea of pass-by-reference, and sizeof on pointers versus arrays. Common questions ask about snippet output, static versus auto, recursion with a reference parameter, and the complexity of a C triple loop. Solve every C PYQ on paper, slowly. Then solve any extra traces you have. Move on when given a short C program that uses static variables and pointers, write the exact output without running it. Leave C library tours, bitwise puzzle collections until later.

This topic is worth ~1.1 marks per paper, and recent questions include about 10; often MSQ. You only need truth tables (one hour) to begin. It also prepares you for K-map, combinational design, sequential next-state, some propositional calculations. Study identities, duality, SOP/POS, canonical forms, don’t-cares, XOR as odd parity. A useful way to solve these questions is to for MSQ equivalence, evaluate on 2–3 assignments instead of algebraic pride. Be careful about don’t-cares change the minimal form; mixing SOP/POS. Common questions ask about which is NOT a tautology; minimise / count literals; equivalent forms. All algebraic PYQs; K-map after B1.3. Move on when simplify a 4-variable expression two ways and get the same cost. Leave tabular / Quine–McCluskey entirely until later.

This topic is worth ~1.1 combined marks per paper, and recent questions include about 10 across the three leaves. You do not need any special prerequisites. It also prepares you for posets/lattices, relational model, FDs, some counting. Study operations, power set, product; RST properties; equivalence vs order; inj/surj/bij; composition. Work through each question step by step. Be careful about onto from a finite set; empty-relation edge cases. Those ~10 PYQs, then stop. Do not farm set-identity worksheets. Move on when given a relation as a matrix or list, classify it in under two minutes. Leave lattice theory (Phase 3+) until later.

This topic is worth ~1.3 marks per paper, and recent questions include about a dozen clean translation / validity questions. You only need connectives to begin. It also prepares you for TOC, Boolean, later tuple calculus, GA logic. Study validity / tautology / satisfiability; English→FOL; quantifier negation; exactly-two. Work through each question step by step. Be careful about ¬∀x P(x) vs ∀x ¬P(x); “none of my friends are perfect”; quantifier scope. All clean logic PYQs. Move on when translate “not all rainy days are cold” and its friends without notes. Leave resolution theorem proving; prenex as a skill until later.

This topic is worth ~0.5 marks per paper, and recent questions include about 7. You only need binary to begin. It also prepares you for floating point, ALU, cache bits, CIDR masks. Study sign-magnitude, 1’s / 2’s, overflow vs carry, range, unsigned wrap. Work through each question step by step. All fixed-point PYQs. Move on when 8-bit 2’s range, overflow vs carry, negate any pattern. Leave booth, restoring division unless a PYQ forces it until later.

This topic is worth ~0.9 marks per paper, and recent questions include about 8 counting + graph-counting prompts under connectivity. You do not need any special prerequisites. It also prepares you for probability, some graph counting. Study product/sum, permutations with repetition, combinations, stars-and-bars, light inclusion-exclusion, pigeonhole. Work through each question step by step. Be careful about labelled vs unlabelled; overcounting. All counting PYQs plus the graph-counting ones. Move on when choose permutation vs combination in 15 seconds; compute nCr without panic. Leave generating functions until later.

This topic is worth ~2.7 combined marks per paper, and recent questions include about 10 recursion + 12 linear-DS. You only need C to begin. It also prepares you for trees, BFS/DFS, D&C, activation records. Study call trees; stack contents; queue vs stack; pointer updates. Work through each question step by step. Be careful about recursion with shared reference parameters; off-by-one on lists. All recursion + stacks/queues/LL PYQs. Move on when unroll a recursion into a call tree and compute the return. Leave fancy deque variants until later.

This topic is worth ~2.5 combined marks per paper, and recent questions include about 9 BST + 8 heaps + 6 trees. You only need recursion, linked trees to begin. It also prepares you for B/B+ indexing, heapsort, priority queues. Study traversals; BST property; insertion counts; heap array indices; heapify. Children 2i+1, 2i+2 (0-based); height of complete tree ⌊log₂ n⌋. Work through each question step by step. Be careful about heap vs BST; 0-based vs 1-based; 3rd-largest in a complete BST stored as an array. Common questions ask about preorder of a BST → unique tree → postorder; height n−1 insertion sequences (only skew). All tree-family PYQs. Move on when rebuild a BST from a traversal pair; show a heap after insert/delete. Leave full AVL/Red-black implementation — know rotation as an idea until later.

This topic is worth ~2.3 marks per paper, and recent questions include about 19 — a must-master pile. You only need counting, basic sets to begin. It also prepares you for traversals, MST, SP, colouring, routing, deadlock graphs. Study handshaking; tree ⇔ connected + n−1 edges; planar v−e+f=2; labelled cycle counts. Work through each question step by step. Be careful about labelled vs unlabelled; simple vs multi; strong connectivity; bounded faces vs total faces. All connectivity PYQs. Move on when prove or disprove a 2-statement graph MSQ in 4 minutes. Leave matching theory, chromatic polynomials until later.

This topic is worth ~1.5 marks per paper, and recent questions include about 14. You only need graph vocab, queues (BFS), stacks/recursion (DFS) to begin. It also prepares you for MST, shortest paths, many “which statements” items. Study tree/back/forward/cross; discovery/finish; directed vs undirected; bipartiteness via BFS. Work through each question step by step. Be careful about assuming DFS tree contains all bridges; mixing undirected back-edges with directed types. All traversal PYQs. Move on when given a trace, reconstruct edge types; know what DFS cannot tell you.

This topic is worth ~3.3 combined marks per paper, and recent questions include about 26 complexity + 5 recurrences. You only need counting, logs, recursion trees to begin. It also prepares you for every algorithm family. Study O/Θ/Ω, limit comparison, hierarchy including log(n!), unfolding, Master theorem. Master theorem; log(n!) ~ n log n; geometric sums. Work through each question step by step. Be careful about worst vs average; NP-complete vs in NP; tightest upper bound vs Θ. Common questions ask about order these functions; tightest bound of BST insert; merge-sort on n strings of length n. All complexity + recurrence PYQs. Move on when place any standard function in the hierarchy; solve a 3-case Master recurrence in 3 minutes. Leave formal NP-completeness reductions — definitional literacy is enough until later.

This topic is worth ~2.3 combined marks per paper, and recent questions include about 7 + 7 + 4 K-map. You only need boolean algebra; short K-map interlude to begin. It also prepares you for ALU (thin), some COA. Study adders, mux/decoder; SR/JK/D/T; excitation tables; state diagrams; counters. Work through each question step by step. Be careful about unused states; async vs sync; assuming a counter is binary. All combinational, sequential, and K-map PYQs. Move on when from a state table, write excitation equations at block level.

This topic is worth ~2.9 combined marks per paper, and recent questions include about 10 FA + 12 RL + 6 regex. You only need logic, sets to begin. It also prepares you for lexing, CFL contrast, sequential-circuit analogy. Study NFA/DFA, subset construction, minimization, regex, closure properties. Work through each question step by step. Be careful about assuming {aⁿbⁿ} is regular; NFA ≠ DFA in power (false). The whole regular cluster. Move on when build a DFA from a realistic regex; answer a 4-statement RL MSQ from the closure table. Leave pumping-lemma writeups until later.

This topic is worth ~1.1 marks per paper, and recent questions include about 10. You only need relations (math) to begin. It also prepares you for SQL, tuple calculus, a bit of NF thinking. Study σ, π, ⋈, ×, ∪, −, ÷, renaming. Work through each question step by step. Be careful about division; attribute-name clashes; confusing RA with the SQL SELECT list. All RA PYQs. Move on when write RA for a two-join English query and estimate cardinality.

This topic is worth ~2.0 combined marks per paper, and recent questions include about 6 syscalls + 13 scheduling. You only need C helps to begin. It also prepares you for sync, deadlock, I/O scheduling later. Focus on the main ideas in this unit. TAT = CT − AT; WT = TAT − BT. Work through each question step by step. Be careful about preemptive vs not; aging; idle time in averages. All syscall + CPU scheduling PYQs. Move on when gantt + three averages for SRTF/RR without notes. Leave I/O scheduling, IPC lectures until later.

This topic is worth ~1.1 marks per paper, and recent questions include about 9. You only need bits to begin. It also prepares you for pipeline hazards. Study modes; instruction-format bit-budget; opcode + regs + immediate. Work through each question step by step. Be careful about byte vs word addressing; alignment; PC-relative offset units. All addressing-mode PYQs. Move on when given register count and opcode count, compute leftover immediate bits.

This topic is worth ~2.8 combined marks per paper, and recent questions include about 18 cache + 4 hierarchy — must-master. You only need bits, number representation, ISA to begin. It also prepares you for cache EAT, virtual memory. Focus on the main ideas in this unit. #sets = C/(assoc×block); offset=log2(block); index=log2(sets); tag = addr−index−offset. A useful way to solve these questions is to always draw the address box. Write-back ⇒ dirty bit exists.. Be careful about bits vs bytes; 4-way means 4 lines per set; replacement-bit count. Common questions ask about tag bits; tag-directory size; which set does block j go to. All cache + hierarchy PYQs. Move on when any cache-spec → tag/index/offset in under 3 minutes. Leave multi-level cache research variants until later.

This topic is worth ~0.7 marks per paper, and recent questions include about 5, all NAT. You only need cache mapping to begin. It also prepares you for TLB EAT in VM. Focus on the main ideas in this unit. EAT = hit×T_hit + miss×(T_hit + penalty) — confirm the paper’s convention. Work through each question step by step. All 5. Move on when re-derive EAT from the problem text rather than memorising one equation.

This topic is worth ~1.5 marks per paper, and recent questions include about 12. You only need relational algebra to begin. It also prepares you for harder nested queries later. Focus on the main ideas in this unit. Work through each question step by step. Be careful about NULL in NOT IN; COUNT(*) vs COUNT(col); duplicates; correlated subquery. All SQL PYQs. Move on when mentally execute a 2-table query including a subquery.

This topic is worth ~2.3 combined marks per paper, and recent questions include about 10 CIDR + 8 fragmentation. You only need binary + a 2-page layering note to begin. It also prepares you for NAT (thin), TCP header accounting. Focus on the main ideas in this unit. #addresses = 2^{32−prefix}; offset in 8-byte units; payload per fragment floored to multiple of 8. Work through each question step by step. Be careful about forgetting header on each fragment; last fragment M=0; HLEN in 4-byte words. All CIDR + fragmentation PYQs. Move on when third-fragment header fields for a 4404-byte / 1500 MTU style question, first try.

This topic is worth ~1.5 combined marks per paper, and recent questions include about 8 sorting + 6 hashing + binary search as an attach. You only need arrays, complexity to begin. It also prepares you for heap-sort already covered; collision intuition for probability. Study comparison lower bound; stable vs in-place; chaining vs open addressing; load factor. Work through each question step by step. All three leaves. Move on when state n log n lower bound and a collision-resolution trace. Leave universal hashing theory until later.

This topic is worth ~1.7 combined marks per paper, and recent questions include about 9 cond + 6 RV + Bayes when ready. You only need counting to begin. It also prepares you for hashing intuition, GA quant. Focus on the main ideas in this unit. P(A|B); Bayes; total probability; linearity of expectation always. Work through each question step by step. Be careful about with vs without replacement; restart-the-experiment processes; assuming independence for Var. Cond + RV PYQs. Do not camp on Normal/Poisson/Exponential. Move on when draw the tree, not the formula, for any two-stage experiment.

This topic is worth ~2.1 combined marks per paper, and recent questions include about 9 CFG + 8 CFL. You only need regular cluster for contrast to begin. It also prepares you for parsing, PDA later. Study derivation, ambiguity, left recursion; CFL closures; DCFL vs CFL as recognition. Work through each question step by step. Be careful about regular ⊂ CFL ⊂ CSL; intersection of CFL and regular is CFL. All CFG + CFL PYQs. Move on when decide regular vs CF vs neither for 6 standard languages in 5 minutes. Leave PDA constructions, pumping-lemma proofs until later.

This topic is worth ~1.2 marks per paper, and recent questions include about 12. You only need relations + FDs to begin. It also prepares you for integrity attach, some file/index key questions. Study attribute closure → candidate keys → prime attributes → 2NF/3NF/BCNF tests. Work through each question step by step. Be careful about trivial FDs; A→BC vs A→B, A→C; 3NF allows X→A if A prime; BCNF does not. All NF PYQs. Move on when from a 5-attribute FD set, list keys and the highest NF in 6 minutes.

This topic is worth 15 official marks per paper, and recent questions include 10 questions every paper. Quant daily; spatial rising; verbal declining if English is strong. You only need school math to begin. It also prepares you for free marks that do not depend on TOC. Focus on the main ideas in this unit. Work through each question step by step. 3 quant + 1 logical + 1 spatial per session, timed. Move on when A 10-question GA set in 20–25 minutes at ≥ 80%.

This topic is worth ~2.4 marks per paper, and recent questions include about 19. Repeat the 5 nastiest traces until they are boring.. You only need cache / hierarchy, process address space to begin. It also prepares you for TLB EAT, multi-level tables. Focus on the main ideas in this unit. #pages = VAS / page_size; EAT with TLB (confirm walk costs); page-fault service time. Work through each question step by step. Be careful about compulsory faults; LRU stack vs clock; inverted vs multi-level. Common questions ask about (1) FIFO/LRU/OPT on 3 frames (2) which policy matches OPT (3) TLB EAT number. All VM PYQs. Move on when LRU/FIFO/OPT on a 12-ref string in < 4 minutes, plus one TLB EAT.

This topic is worth ~1.7 marks per paper, and recent questions include about 14. You only need ISA, addressing modes, combinational latency to begin. It also prepares you for harder multi-FU timing. Focus on the main ideas in this unit. speedup = (nonpipe × n) / (pipe × (k+n−1+stalls)); throughput = 1/max(stage). Work through each question step by step. Be careful about forgetting fill; average vs max stage; assuming forwarding removes all RAW. Common questions ask about stage-delay split; % instructions that stall; register renaming purpose; F(G(x_i)) with limited FUs. All pipeline PYQs. Move on when any 5-stage stall question and any stage-split throughput question, first sitting.

This topic is worth ~1.7 marks per paper, and recent questions include about 12 — must-master. You only need processes, shared memory as an idea to begin. It also prepares you for deadlock, concurrency control, threads. Study ME, progress, bounded wait; Peterson; TestAndSet / FetchAndAdd; semaphores; lost updates. Work through each question step by step. Be careful about spinlock vs sleeping; P order causing deadlock; assuming x=x+1 is atomic. Common questions ask about semaphore order / deadlock among 3 processes; min/max of a racy counter; does this lock work. All sync PYQs. Move on when min and max of a 4-process racy counter; detect a semaphore deadlock.

This topic is worth ~2.2 marks per paper, and recent questions include about 20. Budget real time.. You only need CFG; learn FIRST/FOLLOW inside this unit if shaky to begin. It also prepares you for SDT, intermediate code. Study FIRST/FOLLOW, LL(1) conflicts, left recursion / factoring, shift-reduce, LR(0)/SLR/LALR/LR(1), LALR merge, #reduce moves. Work through each question step by step. Be careful about FOLLOW vs lookahead; SLR rejecting a valid LR(1) grammar; ε in FIRST. Common questions ask about fill E1,E2,E3 in an LL(1) table; can these LR(1) sets merge; max reduce moves. All parsing PYQs. Move on when build FIRST/FOLLOW and an LL(1) table for a 5-production grammar; classify into the LR hierarchy with a reason. Leave writing yacc; Earley; GLR until later.

This topic is worth ~2.2 combined marks per paper, and recent questions include about 10 MST + 5 SP + Floyd-as-DP. You only need graphs, traversals, greedy idea to begin. It also prepares you for routing (DV/LS). Study cut property, cycle property, unique MST; Kruskal/Prim; Dijkstra fails on negatives; Bellman-Ford |V|−1; Floyd DP. Work through each question step by step. Be careful about change this edge, is MST unique; Dijkstra with negative weights vs cycles. All MST + SP PYQs. Move on when answer a unique-MST MSQ without running the full algorithm.

This topic is worth ~1.7 combined marks per paper, and recent questions include about 8 flow + 5 congestion. You only need layering, IPv4 to begin. It also prepares you for HTTP timing intuition. Focus on the main ideas in this unit. Seq/ACK in bytes; slow start +1 per ACK or double per RTT — read the question; AIMD; MSS units. Work through each question step by step. Be careful about delayed ACK changes slope; timeout vs triple-dup; seq += 1 per segment (usually wrong). All flow + congestion PYQs. Move on when one window-trace NAT and one slow-start plot.

This topic is worth ~1.4 marks per paper, and recent questions include about 14. You only need sync, deadlock idea, RA to begin. It also prepares you for recoverability variants. Study conflict vs view serializability; precedence graph; 2PL / strict / rigorous; dirty read; cascadeless. Work through each question step by step. Be careful about conflict ⇏ view in edge cases; 2PL can deadlock; recoverable but not cascadeless. All transaction PYQs. Move on when draw the precedence graph and accept/reject 2PL for a 4-transaction schedule.

This topic is worth ~1.3 combined marks per paper, and recent questions include about 6 SDT + 5 IR. You only need parsing to begin. It also prepares you for local opt, liveness. Focus on the main ideas in this unit. Work through each question step by step. Be careful about action timing bottom-up vs top-down; inherited attributes flowing the wrong way. Common questions ask about print actions of a bottom-up parse; evaluate an SDD; S-attributed vs L-attributed. All SDT + IR PYQs. Move on when simulate a 3-production SDT on a short string. Leave backpatching beyond one worked example until later.

This topic is worth ~0.9 marks per paper, and recent questions include about 6 core + 8 classic variants (knapsack, LIS, MCM) if those 6 are slow. You only need recursion, complexity to begin. It also prepares you for floyd as DP already seen. Focus on the main ideas in this unit. Work through each question step by step. Common questions ask about LCS length/count; matrix-chain; Floyd; shortcut-on-a-line; expression-tree 0/1 leaves. All DP PYQs, then extras only if slow. Move on when write the recurrence before the table for LCS and MCM.

This topic is worth ~0.9 marks per paper, and recent questions include about 7. You only need fixed point to begin. It also prepares you for ALU comments, C float surprises. Focus on the main ideas in this unit. 1+8+23, bias 127, hidden 1, denormals as recognition. Work through each question step by step. Be careful about −14.25 style encoding; hex that look similar with different signs; a+b+c associativity. All IEEE PYQs. Move on when encode −14.25 and decode 0xC1400000-class numbers.

This topic is worth PDA ~0.5 extra marks per paper, and recent questions include revisit missed FA/CFL; all PDA PYQs. You only need regular + CF intro to begin. It also prepares you for undecidability later. Focus on the main ideas in this unit. Work through each question step by step. Missed FA/CFL + PDA. Move on when minimise a small DFA; one PDA construction. Leave formal pumping-lemma writeups as a unit until later.

This topic is worth ~2.0 combined marks per paper, and recent questions include about 20 small-matrix questions. You only need school matrices to begin. It also prepares you for nothing downstream that blocks the paper. Focus on the main ideas in this unit. det, inverse, rank, characteristic polynomial, trace=Σλ, det=Πλ, Aⁿ via λⁿ. Work through each question step by step. Be careful about algebraic vs geometric multiplicity; non-diagonalizable; LU existence. All LA PYQs. Skip a linear-algebra textbook. Move on when eigenvalues of a given 2×2 and of A¹³ using λ¹³.

This topic is worth ~0.9 combined marks per paper, and recent questions include about 6 deadlock + 3 threads. You only need synchronization to begin. It also prepares you for wait-for graphs already seen in txn. Study four conditions; resource allocation + wait-for; Banker's; user vs kernel threads. Work through each question step by step. All deadlock + thread PYQs. Move on when safe-sequence test; which conditions are necessary.

This topic is worth Whatever you are still leaking marks per paper, and recent questions include all tagged PYQs for each weak must-master topic, then 8–15 extras until the gate passes. You only need honest diagnostic to begin. It also prepares you for permission to do mixed sets. Study re-read only the method card — formulas + traps — then drill. Work through each question step by step. Stop when the mastery gate passes, not when a textbook ends. Move on when no must-master topic still in the “unknown concept” bucket. Leave control unit, generating functions, a new standard-book chapter “because it is in the syllabus” until later.

This topic is worth Protects every mark you already “know” marks per paper, and recent questions include 2 NAT + 2 MSQ property + 2 C/recursion + 2 which-statements + 2 leftover, 25–30 minutes. You only need phase 1 holes closed or scheduled to begin. It also prepares you for full-paper stamina. Study mark decision time separately from arithmetic time. Work through each question step by step. 3 mixed tens per week. Move on when you recognise the archetype in 10 seconds even when you still miss Hard items.

This topic is worth Several marks per paper if automated marks per paper, and recent questions include repeat the hardest 5 in each NAT-heavy topic until time < 3 minutes. You only need methods already known to begin. It also prepares you for time to recheck. Study see the NAT table in Score strategy. Work through each question step by step. Timer on, textbook closed. Move on when A 6-NAT burst in 18 minutes at ≥ 5 correct.

This topic is worth 2-mark swings marks per paper, and recent questions include one mixed MSQ set of 8, twice a week. You only need tables written once in your own hand to begin. It also prepares you for fewer 0s on 2-marks you “kind of knew”. Study memorise tables of properties, not procedures. Work through each question step by step. See the MSQ table below. Move on when A 4-statement RL or NF MSQ with no second-guessing.

This topic is worth Hidden inside other tags marks per paper, and recent questions include train pairs, not two topics on two days. You only need both sides of each pair already learned to begin. It also prepares you for fewer “I knew both halves” misses. Study asymptotics+heaps/BST; C+recursion; DFA+CFL; DFS+SP; sync+deadlock; CFG+LL/LR; SP+DV; cache+VM. Work through each question step by step. One pair per sitting. Move on when you notice the second topic in the first read.

This topic is worth Negative-mark insurance marks per paper, and recent questions include after every mock, add one line: trap / why I fell / cue next time. You only need the common-mistakes list on this page to begin. It also prepares you for calmer second pass. Study cue → trap, not story → regret. Work through each question step by step. Read the list the night before a mock, not the morning of. Move on when you can name your ten most expensive traps from memory.

This topic is worth Fractions of a mark in expectation marks per paper, and recent questions include the 1–3 PYQs that exist, then stop. You only need core scoring to begin. It also prepares you for peace of mind, not rank. Study posets, groups/monoids, LU, tuple calculus, generating functions, matching, MVT, pumping writeups, control unit, tabular min, circuit/VC switching, named distributions. Work through each question step by step. One page each, not a chapter. Move on when you can say out loud which remaining topics you are choosing to leave thin. Leave anything that would reopen a finished must-master topic until later.