What are common examiner traps in Data Link Layer?

Unit mismatch: Failing to convert between bytes and bits (multiplying or dividing by 8) for frame size or bandwidth. Metric prefixes: Confusing 1 kbps = 103 bps (networking convention) with 210 bps, or mixing milliseconds (10-3 s) with microseconds (10-6 s) and nanoseconds (10-9 s). One-way vs. Round-Trip Time: Forgetting that total cycle time includes 2 × Tp (round-trip propagation) rather than single Tp. Useful vs. Total Transmission Time: Neglecting to subtract header/overhead bytes when computing useful transmission efficiency if distinct overheads are specified. CRC 0-padding: Appending k zeros instead of (k - 1) zeros for a generator pattern of length k bits. Confusing Selective Repeat sequence space (N ≥ 2Ws) with Go-Back-N sequence space (N ≥ Ws + 1). Failing to ceil the continuous value of window size 1 + 2a to an integer before multiplying by 2 for Selective Repeat sequence space. Unit conversion errors between bits and bytes (e.g., 1 KB = 1024 × 8 bits or 1000 × 8 bits) and milliseconds to seconds. Confusing one-way propagation delay (Tp) with round-trip propagation time (RTT = 2Tp). Misinterpreting polynomial degree: appending r+1 zeros instead of r zeros (where divisor length is r+1). Omitting zero-coefficient terms when converting the polynomial to binary (e.g., mistaking X3 + X + 1 as 111 instead of 1011). Using standard binary division with carry/borrow rather than bitwise XOR (modulo-2) division. Stopping division prematurely or padding leading zeros incorrectly in the final r-bit remainder. Appending the number of bits in the generator instead of its degree (e.g., appending 4 zeros for a 4-bit polynomial of degree 3). Translating polynomials to bitstrings incorrectly by omitting zero coefficients (e.g., writing x3 + x + 1 as `111` instead of `1011`). Confusing error-detection capability (dmin-1) with error-correction capability (⌊ (dmin-1)/2 ⌋). Misidentifying bit index directions (1-based index vs 0-based, or LSB-to-MSB vs MSB-to-LSB) when setting up parity equations in Hamming codes. Confusing bits vs. bytes when calculating Tt = L/B (e.g., 1 KB = 8192 bits or 8000 bits vs. 1 Kb). Forgetting that Selective Repeat requires M ≥ 2 WS while Go-Back-N requires M ≥ WS + 1 when determining sequence bit field width. Neglecting the factor of 2 in round-trip propagation time (2 Tp) or omitting non-zero ACK transmission time (Tt(ack)) when specified in the prompt. Mixing up Pure ALOHA (e-2G) and Slotted ALOHA (e-G) exponents. Destuffing error: removing zeros that were part of original payload instead of strictly removing a '0' only immediately following five consecutive '1's. Neglecting acknowledgement transmission time (Tt,ack) by assuming ACKs are negligible in size. Multiplying propagation delay only once instead of two-way round-trip (2 × Tp). Unit mismatch errors, such as confusing bits and bytes (e.g., 1000 bytes = 8000 bits) or standard metric conversions (1 Kbps = 1000 bps vs 1024 bps). Reporting throughput in bits/second when the question explicitly requests bytes/second. Confusing the broadcast MAC address at layer 2 with a broadcast IP address at layer 3 during ARP request framing. Assuming the default gateway resolves or proxies MAC addresses for hosts located within the same local subnet. Confusing the ARP request (broadcast) with the ARP reply (unicast). Forgetting to multiply byte frame sizes by 8 when working with bandwidth in bps (1250 bytes = 10000 bits). Confusing CSMA/CD with CSMA/CA: assuming RTS/CTS is used for collision detection rather than collision avoidance. Omitting the factor of 2 in Tt ≥ 2 Tp (the round-trip propagation time required to hear a collision). Off-by-one station counts in Token Ring when computing token holding time (whether to include N vs N-1 non-monitor stations). Unit mismatch traps: confusing (10-6 s) with ms (10-3 s), and km/s with m/s. Confusing the function of a jamming signal (alerting network to a collision) with frame padding (ensuring minimum frame length). Assuming carrier sensing occurs only before transmission begins, overlooking that CSMA/CD must continuously sense while transmitting. Believing a node completes sending its frame/packet even after collision detection occurs.

GATE CSE Data Link Layer PYQs

Medium yield24.7% of Computer Networks

Medium Access Control (MAC) in GATE CS is predominantly tested through quantitative numerical problems and conceptual protocol comparisons. The focus is split b… Read the guide

Take topic test

Questions: 27
Asked: since 2013
Total marks: 49
Marks / paper: 1.9

27 GATE CSE Data Link Layer PYQs with solutions, from Computer Networks. Browse all GATE CSE PYQs.

Questions

Every official paper that asked this topic, newest first.

What GATE tests in Data Link Layer

Concepts, patterns, formulas and traps distilled from past papers.

Medium Access Control (MAC) in GATE CS is predominantly tested through quantitative numerical problems and conceptual protocol comparisons. The focus is split between random access protocols (CSMA/CD collision detection constraints and slotted ALOHA transmission probabilities), controlled access (Token Ring round-trip delays and token holding limits), and wireless MAC protocols (IEEE 802.11 CSMA/CA features, channels, and ACK mechanisms). Most questions carry 2 marks and appear in NAT format requiring unit conversions.

Core concepts

Stop-and-Wait Protocol and ARQ efficiency
Sliding Window Protocols (Go-Back-N, Selective Repeat)
Bandwidth-Delay Product (BDP) and Channel Utilization
Sequence Number Field sizing and wrap-around time constraints
Error Detection using Cyclic Redundancy Check (CRC) modulo-2 division
Transmission delay vs. Propagation delay vs. Processing delay trade-offs
Selective Repeat (SR) ARQ Mechanics
Propagation Delay (Tp) vs Transmission Time (Tt)
Link Utilization and Efficiency ( )
Window Sizing (Ws, Wr)
Sequence Number Space Sizing (2k ≥ Ws + Wr)
Cyclic Redundancy Check (CRC) mechanism
Generator polynomial degree and binary bit representation
Appending r zero bits for a degree-r polynomial
Modulo-2 arithmetic (bitwise XOR division)
Codeword construction (M R)
Modulo-2 arithmetic and polynomial division over GF(2)
Cyclic Redundancy Check (CRC) generator polynomial encoding and check-bit calculation
Pairwise Hamming distance and minimum Hamming distance (dmin)
Error-detecting vs error-correcting capability trade-offs
Hamming Code structure, power-of-two check bit placement, and parity equations
CSMA/CD collision detection constraint (Tt ≥ 2 Tp)
Sliding Window Protocols (Stop-and-Wait, Go-Back-N, Selective Repeat)
Window sizing vs. sequence number space requirements (WS + WR ≤ 2k)
Bit-stuffing and bit-destuffing algorithms (e.g., HDLC 5 consecutive 1s rule)
ARP Request (Broadcast MAC) and ARP Reply (Unicast MAC) addressing
Pure ALOHA vs Slotted ALOHA throughput and vulnerable time periods
Stop-and-Wait ARQ protocol timing
Transmission delay vs Propagation delay
Acknowledgement transmission overhead (Tt,ack)
Asymmetric bandwidth rates (Sender vs Receiver)
Throughput calculation in bytes per second
Address Resolution Protocol (ARP) Request and Reply mechanics
Ethernet broadcast MAC address (FF:FF:FF:FF:FF:FF)
Intra-subnet vs. Inter-subnet communication (Direct delivery vs. Default Gateway)
Data Link Layer frame encapsulation of Network Layer packets
CSMA/CD collision detection principle (Tt ≥ 2 Tp)
Slotted ALOHA collision and success probability modeling
Token Ring propagation delay, station holding time, and monitor station duties
IEEE 802.11 CSMA/CA mechanism and why CD fails in wireless
RTS/CTS mechanism for hidden terminal problem / collision avoidance
Link-layer ACK requirement for wireless unicast frames
Non-overlapping channel allocation in IEEE 802.11 (e.g. 1, 6, 11 in 2.4 GHz)
Carrier Sense Multiple Access with Collision Detection (CSMA/CD)
Continuous channel sensing during transmission
Jamming signal function vs. Frame padding
Immediate transmission abortion upon collision
Binary Exponential Backoff algorithm and collision probability reduction

Recurring question patterns

Stop-and-Wait Protocol Efficiency and Parameter Sizing
Commonmixed2 marks2025, 2017, 2015
Calculations involving link utilization $\eta = \frac{T_t}{T_{\text{total}}}$ , determining minimum frame size for target utilization, or finding efficiency with detailed parameters including ACK transmission time, processing overheads, and packet headers.
Sliding Window Sizing and Sequence Number Constraints
Commonmixed2 marks2026
Calculating optimal sender window size $W = 1 + 2a$ for 100% link utilization, or determining the sequence number bit width $N$ under dual constraints of maximum link utilization and sequence number wrap-around time.
Cyclic Redundancy Check (CRC) Modulo-2 Division
OccasionalMCQ2 marks2026
Given a data bit sequence and a generator polynomial bit pattern of length $k$ , finding the $(k-1)$ -bit CRC remainder appended to the frame by performing XOR-based modulo-2 division.
Qualitative Analysis of Protocol Utilization
OccasionalMCQ1 marks2023
Identifying the relationship between protocol efficiency $\eta = \frac{1}{1 + 2a}$ and physical parameters like link distance, bandwidth, frame size, and propagation velocity.
Sequence Number Field Sizing for Sliding Window Protocols
OccasionalNAT2 marks2016
Given channel bandwidth, one-way propagation delay, frame length, and protocol type (e.g., Selective Repeat), compute the frame transmission time, required sender window size for target link utilization (often 100%), total sequence number space size ( $W_s + W_r$ ), and the minimum number of sequence number bits required.
CRC Remainder / Checkbit Calculation
CommonMCQ2 marks2021
Given a generator polynomial $G(X)$ of degree $r$ and a binary data word / message $M$ , calculate the $r$ -bit CRC code (remainder) generated by modulo-2 polynomial division of $(M \cdot 2^r)$ by $G(X)$ .
CRC Transmitted Codeword Computation
CommonMCQ2 marks2017
Given a generator polynomial over GF(2) and a binary information bit sequence, append r zeros (where r is the degree of the polynomial), perform modulo-2 binary division (XOR), and append the remainder to form the transmitted codeword.
Minimum Hamming Distance and Error Bounds
OccasionalMCQ2 marks2017
Given a finite set of binary codewords, compute all pairwise Hamming distances to find the minimum distance $d_{\min}$ , and determine the error detection ( $e$ ) and error correction ( $q$ ) limits.
Hamming Code Parity and Bit Reconstruction
OccasionalMCQ2 marks2021
Given a Hamming code layout with check bits at powers-of-two positions and partial data/check bit assignments, formulate even/odd parity equations to solve for unknown bit values.
CSMA/CD Collision Detection Limit Calculation
Commonmixed2 marks2024, 2013
Given three of the four parameters (bandwidth $B$ , segment length $d$ , propagation velocity $v$ , frame size $L$ ), calculate the missing critical threshold using the fundamental collision detection condition $T_t \ge 2 T_p$ .
Sliding Window Protocol Efficiency and Sequence Sizing
CommonNAT2 marks2021, 2014
Calculate sender window size, total cycle time (including data transmission, round-trip propagation, and optionally ACK transmission delay), or the minimum sequence number field bits required for Go-Back-N or Selective Repeat to achieve a target link utilization.
Random Access Throughput (ALOHA)
OccasionalNAT2 marks2021
Compute the offered load $G = \lambda \times T_{\text{fr}}$ from aggregate Poisson arrival rates and frame transmission time, and evaluate network throughput using the success probability models of Pure or Slotted ALOHA.
Framing Mechanics and Link Layer Addressing
OccasionalMCQ1 marks2021, 2014
Evaluate exact bit/byte stuffing and destuffing patterns given standard flag delimiters (such as 01111110), or determine the unicast vs. broadcast addressing nature of control frames like ARP request/reply.
Stop-and-Wait ARQ Throughput Calculation with ACK Transmission Delay
CommonNAT2 marks2016
Given frame size, sender transmission rate, ACK packet size, receiver transmission rate, and one-way propagation delay, calculate total cycle time and resulting throughput in bytes/second or bps.
Intra-Subnet Address Resolution (ARP over Ethernet)
OccasionalMCQ2 marks2019
Questions asking how a source host resolves the MAC address of a destination host within the same local subnet using ARP broadcast at the Data Link layer.
CSMA/CD Minimum Frame Size & Timing Constraint
CommonNAT2 marks2016, 2015
Given bandwidth, distance/propagation delay, and signal speed or frame size, use the fundamental CSMA/CD constraint $T_t \ge 2 \times T_p$ to calculate the missing parameter (minimum frame size in bytes, signal speed in km/s, or maximum cable length).
Discrete Slot Collision and Success Probability
OccasionalNAT2 marks2015
Calculate the probability that exactly one node transmits successfully in a given time slot without collision, given independent transmission/frame generation probabilities for each node in a slotted LAN environment.
Token Ring Maximum Cycle Time & Timer Limits
OccasionalNAT2 marks2014
Compute the total ring latency and token timer threshold before a monitor station declares the token lost, by summing total ring propagation delay and cumulative token holding times across stations.
Wireless MAC (IEEE 802.11) Protocol Properties
OccasionalMCQ2 marks2016
Conceptual multi-statement evaluation regarding IEEE 802.11 wireless LAN characteristics, including CSMA/CA vs. CSMA/CD, RTS/CTS virtual carrier sensing, non-overlapping 2.4 GHz channels, and unicast ACK requirements.
Conceptual Statement Evaluation of CSMA/CD Protocols
CommonMCQ1 marks2016
Questions present four statements describing operations of the MAC sublayer in Ethernet (such as continuous sensing, collision abortion, jamming signal usage, or backoff window expansion) and ask to identify the TRUE/FALSE statement.

Formulas GATE uses

Transmission Time and Propagation Delay

T_t = \frac{L}{B}, \quad T_p = \frac{d}{v}

Used to compute data/ACK packet transmission times and one-way propagation delays from frame length $L$ , bandwidth $B$ , distance $d$ , and signal speed $v$ .

Stop-and-Wait Efficiency (Standard / Ideal)

\eta = \frac{T_t}{T_t + 2T_p} = \frac{1}{1 + 2a}, \quad \text{where } a = \frac{T_p}{T_t}

Used when processing delay and ACK transmission time are negligible.

Stop-and-Wait ARQ Efficiency (Detailed with Overheads)

\eta = \frac{T_{\text{useful}}}{T_t + 2T_p + T_{\text{proc}} + T_{\text{ack}}}

Used when ACK size, node processing time, or header/payload byte separations are explicitly specified.

Sliding Window Optimal Window Size for 100% Utilization

W \ge 1 + 2a = 1 + 2\left(\frac{T_p}{T_t}\right)

Used to find the minimum sender window size $W$ (in frames) needed to achieve full link utilization.

Sequence Number Space and Wrap-around Time

$2^N \ge \text{Bandwidth (bytes/s)} \times T_{\text{wrap-around}}$ and $2^N \ge W_s + W_r$

Used when determining the minimum sequence number bits $N$ under maximum throughput and lifetime/wrap-around constraints.

CRC Modulo-2 Arithmetic

\text{Appended Bits} = (k - 1) \text{ zeros}, \quad \text{Remainder} = (\text{Data} \cdot 2^{k-1}) \pmod_2 G

Used to compute CRC checksum/FCS bits for an error-detecting generator $G$ of length $k$ .

Frame Transmission Time

T_t = \frac{L}{B}

Used to find the time taken to transmit a data frame of size $L$ over a link of bandwidth $B$ .

Normalized Propagation Delay (a-parameter)

a = \frac{T_p}{T_t}

Used to relate one-way propagation delay $T_p$ to packet transmission delay $T_t$ .

Sliding Window Utilization and Sender Window Size

\eta = \frac{W_s}{1 + 2a} \implies W_s = \lceil 1 + 2a \rceil \quad (\text{for } \eta = 1)

Used to find the minimum integer sender window size $W_s$ required to achieve 100% link utilization.

Selective Repeat Sequence Number Space

N \ge W_s + W_r = 2 W_s

Used to calculate the minimum distinct sequence numbers required in Selective Repeat where $W_r = W_s$ .

Sequence Number Bits Requirement

k = \lceil \log_2 N \rceil

Used to determine the minimum number of bits $k$ allocated in the frame header for the sequence number field.

Polynomial to Binary Generator Divisor Mapping

G(X) = \sum_{i=0}^{r} g_i X^i \implies G = g_r g_{r-1} \dots g_0

Converting a given generator polynomial of degree $r$ into an $(r+1)$ -bit binary divisor.

Augmented Message Construction

M^{\prime}(X) = M(X) \cdot X^r

Appending $r$ zeros to the right of an $n$ -bit message before executing modulo-2 division.

Modulo-2 CRC Remainder Relation

M^{\prime}(X) = Q(X) \cdot G(X) \oplus R(X) \quad \text{where } \deg(R(X)) < r

Finding the $r$ -bit remainder $R$ that serves as the CRC checkbit sequence appended to form the transmitted codeword.

Error-Correcting Capability Bound

d_{\min} \ge 2q + 1 \implies q = \left\lfloor \frac{d_{\min} - 1}{2} \right\rfloor

Used to compute the maximum number of erroneous bits $q$ that a block code with minimum distance $d_{\min}$ can correct.

Error-Detecting Capability Bound

d_{\min} \ge e + 1 \implies e = d_{\min} - 1

Used to compute the maximum number of error bits $e$ guaranteed to be detected.

CRC Appended Zero Count

r = \deg(G(x))

Determines the number of zero bits appended to the message before polynomial division, where $G(x)$ is the generator polynomial.

Hamming Parity Coverage Rule

c_{2^k} = \bigoplus \{ b_i \mid \text{the } k\text{-th bit of binary index } i \text{ is } 1 \}

Used to identify which bit positions are covered by parity bit $c_{2^k}$ under even parity.

CSMA/CD Minimum Frame / Maximum Distance Condition

T_t \ge 2 T_p \implies \frac{L}{B} \ge 2 \frac{d}{v}

Determining minimum frame size, maximum bus distance, or maximum transmission speed in Ethernet CSMA/CD networks.

Sliding Window Protocol Efficiency (with ACK delay)

\eta = \frac{W_S \times T_{t(\text{frame})}}{T_{t(\text{frame})} + 2 T_p + T_{t(\text{ack})}}

Finding link utilization $\eta$ or solving for sender window size $W_S$ given data rate, packet sizes, and round-trip propagation delay.

Selective Repeat Sequence Number Constraint

\text{Total Sequence Numbers } M \ge W_S + W_R = 2 W_S \implies k = \lceil \log_2(2 W_S) \rceil

Computing the minimum number of bits ( $k$ ) in the sequence number field for Selective Repeat ARQ.

Pure ALOHA Throughput

S = G e^{-2G}, \quad \text{where } G = \lambda \times T_{\text{fr}} = \lambda \times \frac{L}{B}

Calculating successfully transmitted frames per unit time under Poisson arrivals with rate $\lambda$ in Pure ALOHA.

Data Transmission Delay

T_{t,\text{data}} = \frac{L_{\text{data}}}{B_{\text{sender}}}

Used to compute the time required by the sender to put all bits of a data frame onto the link.

Acknowledgement Transmission Delay

T_{t,\text{ack}} = \frac{L_{\text{ack}}}{B_{\text{receiver}}}

Used when the acknowledgement frame size is non-negligible and receiver bandwidth is provided.

Total Cycle Time for Stop-and-Wait

T_{\text{total}} = T_{t,\text{data}} + 2 \cdot T_p + T_{t,\text{ack}} + T_{\text{proc}}

Used to calculate the complete elapsed time from the start of frame transmission until full receipt of the acknowledgement.

Sender Throughput

\text{Throughput} = \frac{L_{\text{data}}}{T_{\text{total}}}

Used to calculate useful data delivered per unit time (in bytes/sec or bits/sec).

CSMA/CD Collision Detection Condition

T_t \ge 2 \times T_p \implies \frac{L}{B} \ge 2 \times \frac{d}{v}

Used to find minimum frame length ( $L$ ), maximum distance ( $d$ ), bandwidth ( $B$ ), or propagation speed ( $v$ ) such that collisions are detected before transmission completes.

Propagation Delay

T_p = \frac{\text{Distance } (d)}{\text{Propagation Speed } (v)}

Used to calculate signal transit time over physical media (coaxial, twisted pair, optical fiber, or ring loops).

Transmission Delay

T_t = \frac{\text{Frame Size in bits } (L)}{\text{Bandwidth in bps } (B)}

Used to find the time needed to push all bits of a frame onto the transmission channel.

Token Ring Lost-Token Timeout

T_{\text{timeout}} = T_p + \sum_{i} T_{\text{hold}, i}

Used to determine the maximum round-trip delay a token can take around the ring before the monitoring station assumes loss.

Single Slot Success Probability (Heterogeneous Nodes)

P(\text{Success}) = \sum_{i=1}^{n} \left( P(S_i) \prod_{j e i} (1 - P(S_j)) \right)

Used in slotted ALOHA / synchronous slot models when nodes have distinct transmission probabilities $P(S_i)$ and exactly one node must transmit.

Binary Exponential Backoff Contention Range

R \in \{0, 1, 2, \dots, 2^k - 1\} \quad \text{where } k = \min(i, 10) \text{ on collision } i

Used to determine the random backoff multiplier range and evaluate the probability of collision on subsequent retransmissions.

Examiner traps in Data Link Layer

Unit mismatch: Failing to convert between bytes and bits (multiplying or dividing by 8) for frame size or bandwidth.
Metric prefixes: Confusing 1 kbps = 103 bps (networking convention) with 210 bps, or mixing milliseconds (10-3 s) with microseconds (10-6 s) and nanoseconds (10-9 s).
One-way vs. Round-Trip Time: Forgetting that total cycle time includes 2 × Tp (round-trip propagation) rather than single Tp.
Useful vs. Total Transmission Time: Neglecting to subtract header/overhead bytes when computing useful transmission efficiency if distinct overheads are specified.
CRC 0-padding: Appending k zeros instead of (k - 1) zeros for a generator pattern of length k bits.
Confusing Selective Repeat sequence space (N ≥ 2Ws) with Go-Back-N sequence space (N ≥ Ws + 1).
Failing to ceil the continuous value of window size 1 + 2a to an integer before multiplying by 2 for Selective Repeat sequence space.
Unit conversion errors between bits and bytes (e.g., 1 KB = 1024 × 8 bits or 1000 × 8 bits) and milliseconds to seconds.
Confusing one-way propagation delay (Tp) with round-trip propagation time (RTT = 2Tp).
Misinterpreting polynomial degree: appending r+1 zeros instead of r zeros (where divisor length is r+1).
Omitting zero-coefficient terms when converting the polynomial to binary (e.g., mistaking X3 + X + 1 as 111 instead of 1011).
Using standard binary division with carry/borrow rather than bitwise XOR (modulo-2) division.
Stopping division prematurely or padding leading zeros incorrectly in the final r-bit remainder.
Appending the number of bits in the generator instead of its degree (e.g., appending 4 zeros for a 4-bit polynomial of degree 3).
Translating polynomials to bitstrings incorrectly by omitting zero coefficients (e.g., writing x3 + x + 1 as `111` instead of `1011`).
Confusing error-detection capability (dmin-1) with error-correction capability (⌊ (dmin-1)/2 ⌋).
Misidentifying bit index directions (1-based index vs 0-based, or LSB-to-MSB vs MSB-to-LSB) when setting up parity equations in Hamming codes.
Confusing bits vs. bytes when calculating Tt = L/B (e.g., 1 KB = 8192 bits or 8000 bits vs. 1 Kb).
Forgetting that Selective Repeat requires M ≥ 2 WS while Go-Back-N requires M ≥ WS + 1 when determining sequence bit field width.
Neglecting the factor of 2 in round-trip propagation time (2 Tp) or omitting non-zero ACK transmission time (Tt(ack)) when specified in the prompt.
Mixing up Pure ALOHA (e-2G) and Slotted ALOHA (e-G) exponents.
Destuffing error: removing zeros that were part of original payload instead of strictly removing a '0' only immediately following five consecutive '1's.
Neglecting acknowledgement transmission time (Tt,ack) by assuming ACKs are negligible in size.
Multiplying propagation delay only once instead of two-way round-trip (2 × Tp).
Unit mismatch errors, such as confusing bits and bytes (e.g., 1000 bytes = 8000 bits) or standard metric conversions (1 Kbps = 1000 bps vs 1024 bps).
Reporting throughput in bits/second when the question explicitly requests bytes/second.
Confusing the broadcast MAC address at layer 2 with a broadcast IP address at layer 3 during ARP request framing.
Assuming the default gateway resolves or proxies MAC addresses for hosts located within the same local subnet.
Confusing the ARP request (broadcast) with the ARP reply (unicast).
Forgetting to multiply byte frame sizes by 8 when working with bandwidth in bps (1250 bytes = 10000 bits).
Confusing CSMA/CD with CSMA/CA: assuming RTS/CTS is used for collision detection rather than collision avoidance.
Omitting the factor of 2 in Tt ≥ 2 Tp (the round-trip propagation time required to hear a collision).
Off-by-one station counts in Token Ring when computing token holding time (whether to include N vs N-1 non-monitor stations).
Unit mismatch traps: confusing (10-6 s) with ms (10-3 s), and km/s with m/s.
Confusing the function of a jamming signal (alerting network to a collision) with frame padding (ensuring minimum frame length).
Assuming carrier sensing occurs only before transmission begins, overlooking that CSMA/CD must continuously sense while transmitting.
Believing a node completes sending its frame/packet even after collision detection occurs.

How questions are asked

Direct numerical calculation of link efficiency / utilization percentage
Finding minimum frame size or minimum window size for target efficiency
Bit-level modulo-2 XOR division for CRC remainder determination
Determining sequence number field bit-length under lifetime and utilization constraints
Qualitative comparative MCQ on link parameters (distance, bandwidth, frame size) vs. utilization
NAT calculation of header bit-fields based on physical and protocol link parameters
Compute the CRC checkbit sequence given a generator polynomial and binary message
Calculate transmitted codeword given message bits and CRC generator polynomial
Determine minimum distance and error bounds for a listed set of binary codewords
Solve for unknown bits in a Hamming codeword given a bit-position mapping table
NAT calculating minimum frame length, distance, or bandwidth under CSMA/CD
NAT calculating window size or sequence field bit-width for target sliding window utilization
NAT calculating throughput in frames/sec for Poisson-distributed ALOHA traffic
MCQ destuffing a given bit stream or identifying stuffed bit positions
MCQ statement verification regarding ARP/Ethernet frame header addressing
Numerical calculation of ARQ sender throughput or link efficiency given link characteristics
Conceptual scenario-based multiple-choice question on packet transmission and address resolution
Calculate minimum frame size in bytes given B and Tp (NAT)
Calculate signal speed in km/s given L, B, and d (MCQ/NAT)
Compute collision-free probability across heterogeneous slotted nodes (NAT)
Calculate monitor station timeout for token loss in Token Ring (NAT)
Identify TRUE/FALSE conceptual statements about IEEE 802.11 MAC features (MCQ/MSQ)
True/False protocol statement evaluation MCQ
Multi-Select conceptual validation (MSQ)

Paper trends

Questions have evolved from basic Stop-and-Wait formulas to realistic multi-parameter accounting (considering ACK transmission time, processing delay, data vs. overhead bytes) and dual-constraint window/sequence number design problems.
2026, 2017, 2015
High prevalence of numerical answer type (NAT) and 2-mark computational MCQs that test unit conversions (e.g., bits vs. bytes, kbps vs. bps, nanoseconds per meter).
2026, 2025, 2017, 2015
Emphasis is placed on end-to-end exact integer calculation formatted as Numerical Answer Type (NAT), ensuring candidates understand ceil operations at discrete window sizing and bit-allocation stages.
2016
Direct calculation of CRC checkbits via polynomial division has appeared as a high-weightage 2-mark MCQ requiring careful step-by-step XOR arithmetic.
2021
Questions consistently carry 2 marks and assess step-by-step bitwise mechanics rather than pure qualitative definitions.
2021, 2017
Testing shifted from classic CRC and code distance evaluations (2017) to structured tabular verification of Hamming parity bit relationships (2021).
2021, 2017
Shift from simple multiple-choice calculation questions to NAT questions requiring precise arithmetic (e.g., fractional window sizing rounded to nearest integer, exponential throughput evaluations).
2024, 2021, 2014
Increased precision in sliding window problems, explicitly providing finite ACK transmission frame lengths rather than assuming ACK transmission time is zero.
2021
GATE tests precise multi-component round-trip timing by explicitly specifying non-negligible acknowledgement sizes and receiver transmission rates rather than assuming instantaneous ACKs.
2016
Focuses on conceptual understanding of link-layer framing and broadcast mechanisms (MAC broadcast vs. IP broadcast and direct host vs. gateway involvement).
2019
Transition from direct calculation of protocol limits (Token Ring in 2014) to standard Ethernet CSMA/CD collision-detection constraints and probability-based slotted ALOHA success rates in 2015-2016.
2016, 2015, 2014
High prevalence of 2-mark NAT questions requiring multi-step arithmetic, precise unit conversions (bits to bytes, seconds to microseconds, meters to kilometers), and edge tolerance consideration.
2016, 2015, 2014
Direct conceptual 1-mark MCQs test precise protocol mechanics (CSMA/CD operational rules) rather than purely numerical calculations.
2016

Difficulty notes

Easy questions ask for direct application of $\eta = 1/(1+2a)$ or qualitative relationships with negligible overheads (1 mark MCQ or standard 2 mark NAT). Medium questions incorporate multiple real-world parameters (ACK frame size, processing delay, header overheads) or multi-step logic combining wrap-around time constraints and BDP for sequence number sizing (2 mark NAT or MCQ). Hard questions (rare) combine packet error rates, retransmission timeouts, and asymmetric sliding windows.