GATE CSE 2027 Preparation

Trace insertion, deletion, and reversal operations on singly and doubly linked lists.

Trace stack operations in array and linked representations, including overflow and underflow conditions.

Trace queue and circular-queue operations in array and linked representations, including full and empty conditions.

Convert between infix, postfix, and prefix expressions and evaluate stack-based expressions.

Derive traversal orders and structural properties of binary trees.

Trace search, insertion, and deletion operations in binary search trees.

Trace binary-heap operations and use heaps to implement priority queues.

Resolve hash-table collisions using chaining and open addressing and calculate probe sequences.

Derive time and space complexity for iterative or recursive code and compare growth rates using asymptotic bounds.

Solve divide-and-conquer running-time recurrences using substitution, recursion trees, and the Master theorem.

Trace comparison-based sorting algorithms and compare their time, space, and stability properties.

Represent graphs and use breadth-first or depth-first traversal to derive reachability, components, and topological orders.

Construct greedy solutions and test whether the greedy-choice property holds.

Formulate dynamic-programming states, transitions, base cases, and evaluation order.

Compute minimum spanning trees using Kruskal’s and Prim’s algorithms.

Compute single-source shortest paths and select an appropriate shortest-path algorithm for a given graph.

Translate statements into propositional or first-order logic and determine validity using formal reasoning.

Perform set operations and determine the defining properties, compositions, and closures of functions and relations.

Compute equivalence classes and represent partial orders with Hasse diagrams to determine bounds and lattice properties.

Classify algebraic structures by testing closure, identity, inverses, and associativity.

Solve counting problems using permutations, combinations, pigeonhole reasoning, and inclusion–exclusion.

Solve linear recurrence relations and extract coefficients from simple generating functions.

Determine graph connectivity, tree properties, degree constraints, and Eulerian or Hamiltonian properties.

Solve graph problems involving planarity, coloring, independent sets, vertex covers, and matching.

Solve systems of linear equations using matrix rank and row reduction.

Compute eigenvalues and eigenvectors and use them to analyze a matrix.

Evaluate limits of single-variable functions using algebraic transformations, standard limits, series expansions, and L’Hôpital’s rule.

Determine continuity and differentiability and apply Rolle’s and mean-value theorems to single-variable functions.

Find local and global extrema of single-variable functions using derivative tests and endpoint analysis.

Evaluate definite and improper integrals using standard techniques.

Compute conditional probabilities using independence, total probability, and Bayes’ theorem.

Compute probabilities and descriptive measures—including expectation and variance—for common discrete and continuous distributions.

Represent and calculate with signed fixed-point and IEEE 754 floating-point numbers, including normalization, rounding, and overflow.

Decode machine instructions and compute effective addresses for standard addressing modes.

Trace data movement through registers, an ALU, the processor datapath, and the control unit during instruction execution.

Calculate pipeline execution time, speedup, and stalls caused by structural, data, and control hazards.

Compare memory-hierarchy technologies and calculate effective memory-access time from hit and miss behavior.

Calculate tag, index, and offset widths and storage overhead for direct-mapped, set-associative, and fully associative caches.

Trace memory-reference sequences to determine cache hits, misses, replacements, and write-policy updates.

Trace programmed I/O, interrupt-driven I/O, and DMA transfers and compare their processor overhead.

Convert regular expressions into equivalent nondeterministic finite automata.

Convert nondeterministic finite automata into deterministic finite automata using subset construction.

Minimize a deterministic finite automaton and test whether two states or automata are equivalent.

Use closure properties and the pumping lemma to test claims about regular languages.

Generate and parse strings with context-free grammars and detect ambiguity in derivations.

Construct pushdown automata for standard context-free languages and relate them to grammars.

Use closure properties and pumping arguments to test claims about context-free languages.

Construct simple Turing-machine computations and classify problems as decidable, recognizable, or undecidable using reductions.

Identify the outputs of compiler phases and construct a lexical analyzer from token regular expressions and finite automata.

Compute FIRST and FOLLOW sets for grammars containing nullable non-terminals and epsilon productions.

Construct LL(1) predictive-parsing tables and identify parsing conflicts.

Identify viable prefixes and handles and trace shift-reduce parsing for a context-free grammar.

Construct LR item sets and an SLR parsing table for a small grammar.

Use synthesized and inherited attributes in syntax-directed definitions to evaluate expressions and generate intermediate code.

Determine runtime storage organization and trace parameter-passing mechanisms.

Generate three-address code and basic blocks, then apply DAG, liveness, common-subexpression, and dead-code optimizations to small programs.

Convert an entity–relationship design into a relational schema with appropriate constraints.

Evaluate relational-algebra expressions and translate simple tuple-relational-calculus queries involving selection, projection, joins, and division.

Write and trace SQL queries using joins, nested queries, aggregation, and NULL semantics.

Compute attribute closures and identify candidate keys from functional dependencies.

Decompose schemas into 3NF or BCNF and test lossless join and dependency preservation.

Calculate record placement and lookup costs for file organizations and B/B+ tree indexes.

Test transaction schedules for conflict serializability, view-equivalence conditions, recoverability, and cascadelessness.

Trace locking, timestamp-ordering, and logging-based recovery protocols.

Trace encapsulation through the network layers and calculate delay, throughput, and bandwidth–delay product.

Detect transmission errors using parity, checksums, and cyclic redundancy checks.

Compute window sizes, sequence-number limits, retransmissions, and utilization for Stop-and-Wait, Go-Back-N, and Selective Repeat.

Calculate collision timing, minimum frame size, throughput, and backoff behavior for ALOHA and CSMA/CD.

Trace Ethernet frames and learning-switch table updates, forwarding, and filtering.

Perform IPv4 subnetting and longest-prefix matching for forwarding-table lookups.

Compute routing outcomes using distance-vector and link-state algorithms.

Calculate IPv4 fragmentation fields and trace address or header changes involving ARP, ICMP, DHCP, and NAT.

Compare UDP and TCP headers and trace multiplexing, connection establishment or termination, acknowledgments, retransmission, and flow control.

Trace TCP congestion-window and threshold changes during slow start, congestion avoidance, fast retransmit, and fast recovery.

Calculate latency for non-persistent, persistent, and pipelined HTTP connections.

Trace recursive and iterative DNS resolution and the protocol exchanges used for common email delivery and retrieval tasks.

Diagnose Operating Systems gaps by solving a timed mixed set of process, concurrency, memory, file-system, and I/O PYQs.

Diagnose Digital Logic gaps by solving a timed mixed set of combinational, sequential, and number-system PYQs.

Apply question-selection, guessing-risk, and two-pass attempt rules to a representative timed multi-subject test set.

Analyze mock performance by subject, error type, and time spent to choose the next revision priorities.

Correct sentence-level errors involving grammar, usage, and word relationships.

Derive logical inferences, identify assumptions, and draw supported conclusions from short passages.

Solve percentage, ratio, average, profit-and-loss, and mixture problems.

Solve numerical-computation problems involving powers, exponents, logarithms, estimation, and number or letter series.

Solve time-and-work and time–speed–distance problems.

Interpret tables, charts, and multi-step quantitative data sets accurately.

Solve analytical-reasoning problems using seating, grouping, sequencing, and constraint elimination.

Solve geometry, mensuration, and spatial-reasoning problems involving transformations, paper folding, and 2D or 3D assembly.