UGC NET CS & Applications — Question Pattern Intelligence Report

UGC NET
Computer Science & Applications (Paper
II)
Question Pattern Intelligence Report

Decoding the Source, Logic & Recurring Patterns Behind 2013–2025 Question Papers
With a Tier-Based Prediction & Preparation Strategy for the Upcoming Cycle

Prepared June 2026

Independent analytical study aid — not an official NTA / UGC publication

Page 1
 UGC NET CS & Applications — Question Pattern Intelligence Report

Table of Contents
TOC \h \o "1-3"

Page 2
 UGC NET CS & Applications — Question Pattern Intelligence Report

Executive Summary
UGC NET Computer Science & Applications (subject code 87, Paper II) is a 100-question, 200-
mark, negative-marking-free objective test drawn from a 10-unit syllabus that has remained
structurally stable since the June 2019 syllabus revision, with a light enrichment in 2024
(Optimisation/Operations Research added to Unit 1; Big Data, NoSQL, Cloud and IoT folded
into Units 4 and 9). Despite the syllabus looking enormous on paper, the actual question paper
is far more predictable than it appears — because the people who set it are constrained by the
same things every cycle: a fixed set of canonical textbooks, a fixed unit structure, and a fixed
menu of MCQ “wrapper” formats.
This report works backward from that constraint. It maps each syllabus unit to the textbook(s) its
sub-topics are lifted from, shows how those textbook concepts get re-packaged into assertion-
reason, match-the-following, statement-based, sequencing and numerical questions, and
quantifies (from years of PYQ analysis) which units and sub-topics consistently carry the most
marks. It closes with a tier-based prediction for the next cycle and a prioritised preparation plan.

Key Findings at a Glance

• Four units decide the exam. Data Structures & Algorithms, Operating Systems, DBMS
and Computer Networks together account for roughly 45–50% of Paper II marks (about
42–48 of the 100 questions) in every cycle from 2019 onward.
• The syllabus is a textbook table of contents in disguise. Each unit’s sub-topic list
maps almost line-for-line onto a specific standard reference (e.g. Unit 2 mirrors Morris
Mano’s Computer System Architecture chapter order; Unit 4 mirrors Elmasri & Navathe’s
Fundamentals of Database Systems; Unit 5 mirrors Silberschatz, Galvin & Gagne’s
Operating System Concepts). Knowing the source book tells you which depth level and
which solved examples a question is likely paraphrased from.
• Roughly a quarter of questions are recycled concepts. The same conceptual core —
functional dependency reasoning, process-state transitions, MST/BFS/DFS, CFG
closure properties, TCP/IP numericals, cache write policies — reappears cycle after
cycle, simply re-wrapped in a different question format or with different numbers.
• GATE CSE is a feeder pool. Roughly 70–80% of the core-unit syllabus overlaps with
GATE CSE, and many UGC NET numerical questions (TLB, Master theorem
recurrences, subnetting, scheduling) are softened versions of GATE-style problems.
• New syllabus keywords get ‘starter’ questions first. When a topic is newly added to
the syllabus (e.g. Big Data/NoSQL in 2019, Optimisation/PERT-CPM in 2024), the first
few cycles after the change tend to test it at a basic, definitional level before deeper
numericals appear — because the question bank for that topic is still thin.
• The question ‘wrapper’ has shifted since 2021. Recent cycles (2023–2026) lean
heavily on assertion-reason pairs, multi-statement true/false sets, and chronological-
ordering questions rather than plain one-line recall — testing the same concepts but
demanding more careful reading.

Page 3
 UGC NET CS & Applications — Question Pattern Intelligence Report

Section 1 — How the Exam Itself Has Evolved (2013–

2026)
Before you can spot a pattern across 2013–2025 papers, you need to know that the exam was
not the same exam throughout that window. Three structural shifts changed what “a question
paper” even meant, and PYQ sets from before 2018 need to be read with that context.

1.1 The Three-Paper Era (up to 2018)

Until the December 2018 cycle, UGC NET (then still partly conducted by CBSE before NTA took
over in 2018) used three papers for every subject:
• Paper I: a general, common paper on teaching and research aptitude (60 marks).
• Paper II: 50 objective questions (100 marks) on the subject’s foundational topics.
• Paper III: 75 objective questions (150 marks) covering the subject in greater depth,
including more applied and advanced topics.
For Computer Science, this meant the “core” topics (programming, data structures, OS, DBMS,
networks) were spread across both Paper II and Paper III, with Paper III going deeper into
algorithms, advanced architecture, software engineering and AI. When you encounter a pre-
2018 “Paper III” PDF, treat it as the ancestor of today’s harder/more analytical questions.

1.2 The NTA Reform (from 2018 onward)

From the 2018 cycle, the National Testing Agency (NTA) took over UGC NET and collapsed the
three papers into two:
• Paper I: 50 questions, 100 marks, 1 hour — common general aptitude paper for every
subject.
• Paper II: 100 questions, 200 marks, 2 hours — entirely subject-specific.
Both papers run back-to-back in a single 3-hour CBT session with no break, and there is no
negative marking in either paper. Functionally, the old Paper II and Paper III content for
Computer Science was merged into the new, larger Paper II — which is why the post-2018
Paper II syllabus looks denser and covers both “foundational” and “applied/advanced” topics in
the same 10 units.

1.3 The June 2019 Syllabus Standardisation

In June 2019, UGC issued a revised syllabus for most Paper II subjects, including Computer
Science. This is the syllabus that introduced the now-familiar 10-unit structure running from
“Discrete Structures” through “Artificial Intelligence,” and it has remained the backbone of every
paper from late 2019 through the present. If you are analysing 2013–2018 papers, expect some
topic-ordering and emphasis differences versus 2019–present papers — the underlying CS
fundamentals are the same, but the unit boundaries and a few topic names changed.

1.4 The 2024 Enrichment (current syllabus)

The most recent revision (reflected in the 2024–2026 cycles) kept the same 10-unit skeleton but
enriched two units with topics that track where postgraduate CS curricula have moved:

Page 4
 UGC NET CS & Applications — Question Pattern Intelligence Report

• Unit 1 (“Discrete Structures and Optimization”): Linear Programming, the Simplex

and Dual-Simplex methods, Integer Programming, Transportation and Assignment
models, and PERT-CPM project-scheduling techniques were added — essentially an
Operations Research add-on to what used to be a pure discrete-mathematics unit.
• Unit 4 (DBMS) and Unit 9 (Networks): Big Data characteristics, MapReduce/Hadoop,
HDFS and NoSQL querying were folded into the DBMS unit, while Cloud Computing
(SaaS/PaaS/IaaS) and IoT basics were folded into the Networks unit.
Practical implication: if you are working from an older (pre-2024) PYQ set or notes, you may be missing
the Optimisation/OR sub-topics in Unit 1 and the Big Data/Cloud/IoT sub-topics in Units 4 and 9 — both
of which have started appearing as standalone questions from 2024 onward.

1.5 What This Means for a 2013–2025 Pattern Study

Read the timeline in three blocks rather than as one continuous series:
1. 2013–2018 (pre-NTA, three-paper era): use these papers mainly to confirm which core
CS concepts have always been tested — the conceptual spine (data structures, OS,
DBMS, networks, automata theory) is identical to today’s, even though the paper layout
differs.
2. 2019–2023 (NTA, 10-unit syllabus, two-paper format): this is the most directly
comparable block to the present — same unit structure, same 100-question/200-mark
Paper II, same no-negative-marking rule.
3. 2024–present (enriched syllabus): same structure as block 2, plus the Optimisation/OR
and Big Data/Cloud/IoT additions described above. This is the block to weight most
heavily when predicting the next paper.

Page 5
 UGC NET CS & Applications — Question Pattern Intelligence Report

Section 2 — The “Secret”: Where These Questions

Actually Come From
Question setters for a national-level exam covering 85 subjects do not have time to invent
original research-level questions for every cycle. What they do instead — visible once you
compare enough papers — is draw from four predictable sources. Understanding these four
sources is the real “crack” behind the paper.

2.1 Source 1: The Syllabus Is a Textbook Table of Contents

The single most useful observation is that almost every unit’s sub-topic list is not an original
syllabus design — it is the chapter list of one or two standard postgraduate-level textbooks,
lightly reworded. Question setters (who are CS faculty drawn from universities) write questions
by picking a sub-heading from the syllabus, going to the matching chapter of the “canonical”
book for that unit, and adapting a definition, diagram, theorem, or solved example into an MCQ.
The table below maps each unit to the book(s) whose structure it mirrors most closely — these
are the books worth mining for likely question material.

Canonical Source Text(s) the Unit

Unit Core Topics
Mirrors
1. Discrete Structures & Logic, sets/relations, counting, Kenneth Rosen — Discrete
Optimization group theory, graph theory, Mathematics & Its Applications;
Boolean algebra, LPP/PERT- Trembley & Manohar; for the
CPM Optimisation add-on, a standard
Operations Research text (Taha /
Hamdy)
2. Computer System Digital logic, data M. Morris Mano — Computer System
Architecture representation, register Architecture (the unit’s topic order is
transfer, CPU design, essentially this book’s chapter order)
pipelining, memory hierarchy,
multiprocessors
3. Programming C/C++ fundamentals, OOP, E. Balagurusamy — Programming in
Languages & Computer web basics, raster graphics, C / C++ with Object-Oriented
Graphics 2D/3D transforms, clipping Programming; Hearn & Baker —
Computer Graphics, C Version
4. Database Management ER model, relational Elmasri & Navathe — Fundamentals
Systems algebra/calculus, SQL, of Database Systems (chapter order
normalisation, transactions, matches almost section-for-section);
concurrency, data Silberschatz et al. — Database
warehousing, Big Data/NoSQL System Concepts as a secondary
source
5. System Software & Process/thread management, Silberschatz, Galvin & Gagne —
Operating System CPU scheduling, deadlocks, Operating System Concepts (the
memory management, file “dinosaur book” — unit headings
systems, security, mirror its part divisions almost exactly)
Linux/Windows internals
6. Software Engineering Process models, requirements, Roger Pressman — Software

Page 6
 UGC NET CS & Applications — Question Pattern Intelligence Report

Canonical Source Text(s) the Unit

Unit Core Topics
Mirrors
design, quality, estimation Engineering: A Practitioner’s
(COCOMO), testing, Approach; Ian Sommerville —
configuration management Software Engineering
7. Data Structures & Arrays, trees, graphs, hashing, Cormen, Leiserson, Rivest & Stein —
Algorithms complexity analysis, divide & Introduction to Algorithms (CLRS);
conquer, DP, greedy, NP- Horowitz, Sahni & Anderson-Freed —
completeness Fundamentals of Data Structures
8. Theory of Computation & DFA/NFA, regular languages, Hopcroft, Motwani & Ullman —
Compilers CFG/PDA, Turing machines, Introduction to Automata Theory,
parsing, code generation Languages and Computation; Aho,
Sethi & Ullman — Compilers:
Principles, Techniques and Tools (the
“Dragon Book”)
9. Data Communication & Data communication basics, Behrouz Forouzan — Data
Computer Networks OSI/TCP-IP, addressing, Communications and Networking;
routing, WWW/email protocols, Tanenbaum & Wetherall — Computer
security, mobile/cloud/IoT Networks (secondary)
10. Artificial Intelligence Search/game playing, Russell & Norvig — Artificial
knowledge representation, Intelligence: A Modern Approach; Rich
planning, NLP, fuzzy sets, GA, & Knight — Artificial Intelligence
ANN (older-style questions)
Why this matters: when a question feels oddly specific — a named theorem, a particular diagram, an
unusual algorithm variant — it is very likely lifted from a worked example or end-of-chapter exercise in
one of these books. Practising the solved examples and exercises in these specific texts (not just
“general notes”) closes a large share of the gap between “I know the topic” and “I recognised that exact
question.”

2.2 Source 2: GATE CSE as a Feeder Pool

GATE CSE and UGC NET Computer Science share roughly 70–80% of their core syllabus —
data structures, algorithms, OS, DBMS, computer networks, computer organisation, TOC and
compilers are essentially the same subject lists. Because GATE has a 25+ year archive of
rigorously reviewed numerical and conceptual questions, NTA question setters routinely adapt
GATE-style problems for NET, usually by:
• simplifying the numbers or removing one step of a multi-step calculation,
• converting a GATE numerical-answer question into an MCQ with plausible distractors,
• or keeping the scenario but changing the specific algorithm/protocol/data values.
In practice, this means GATE CSE PYQs on cache memory and TLB calculations, CPU
scheduling (FCFS/SJF/Priority/Round Robin), page replacement (LRU/Optimal/FIFO), TCP
window/sequence-number arithmetic, subnetting, recurrence relations (Master theorem), MST
and shortest-path tracing, and grammar/automata construction are an extremely high-yield
practice source — arguably second only to the canonical textbooks themselves.

Page 7
 UGC NET CS & Applications — Question Pattern Intelligence Report

2.3 Source 3: NET Recycles Itself

A consistent finding across multiple cycles is that a meaningful share of each paper —
commonly estimated in the 15–30% range by experienced UGC NET educators — consists of
concepts that have already been tested in earlier cycles, reappearing with one or more of the
following changes:
• the same concept tested via a different question format (e.g. a fact that was once a
direct one-liner now appears as an assertion-reason pair or inside a multi-statement
true/false set),
• the same scenario with different numeric values (e.g. a different page size or different
process burst times in a scheduling question),
• the same theorem or property tested from the opposite direction (e.g. “which of these is
NOT a property of…” instead of “which of these IS…”).
Concretely, topics that show up this way across many cycles include:
functional-dependency/normalisation reasoning in DBMS, process-state transition and context-
switch questions in OS, BFS/DFS/MST/shortest-path questions in graph theory, closure
properties of regular and context-free languages in TOC, and cache write-policy questions in
computer organisation. Solving 8–10 years of past NET papers for these specific topics, rather
than only the most recent one or two, surfaces the “rotation” of variants directly.

2.4 Source 4: Newly Added Syllabus Keywords Get ‘Starter’ Questions

Every time UGC revises the syllabus and adds a genuinely new keyword-topic — Big
Data/Hadoop/NoSQL after the 2019 revision, or Optimisation/PERT-CPM, GIS and genome
data management after the 2024 revision — a predictable pattern follows: the first two or three
cycles after the addition tend to test that topic at a basic, definition-or-terminology level (“what
does HDFS stand for,” “which of the following is a NoSQL database type,” “what is the objective
function in an LPP”), because the setters themselves are drawing from the same handful of
introductory paragraphs in the syllabus annexure and a small number of available reference
questions. Deeper, multi-step numericals on these topics (e.g. an actual Simplex-method
iteration, or a multi-table NoSQL query) tend to appear only after the topic has been in the
syllabus for several cycles.
Practical implication for 2026: Optimisation/PERT-CPM (Unit 1) and Big Data/NoSQL/Cloud/IoT (Units 4
& 9) are still relatively ‘young’ syllabus additions. Expect them to contribute 1–3 questions each, pitched
mainly at definitional/terminology level, with a slowly rising chance of a simple numerical (e.g. a one-
iteration Simplex step, an EOQ-style transportation table, or a critical-path calculation on a small project
network).

2.5 Source 5: The Postgraduate-Curriculum Filter

Finally, the 10-unit structure as a whole mirrors the “core papers” of a typical 2-year MCA or
[Link] (CS) programme in India — discrete mathematics, computer organisation, programming
& graphics, DBMS, operating systems, software engineering, data structures & algorithms,
theory of computation & compilers, computer networks, and AI. This is deliberate: UGC NET
Paper II is designed to test “what every computer science postgraduate should know to teach
the subject,” which is why it favours breadth across these ten established pillars over depth in
any single cutting-edge research area. Even the AI unit, despite recent advances in the field, is
still examined largely through classical AI (search, knowledge representation, fuzzy logic, neural
network basics) rather than current deep-learning practice — because that is what the reference
curriculum and textbooks cover.

Page 8
UGC NET CS & Applications — Question Pattern Intelligence Report

Page 9
 UGC NET CS & Applications — Question Pattern Intelligence Report

Section 3 — Unit-Wise Weightage: What Carries the

Marks
NTA does not publish an official marks-per-unit breakup, and the exact count shifts by 1–2
questions from cycle to cycle and even between shifts of the same cycle. The figures below are
consolidated from cross-cycle PYQ analysis (2019–present, with cross-checks against the most
recent December 2025 paper) and should be read as working ranges — useful for allocating
study time, not as guaranteed counts.

Approx. Approx.
Unit Trend Note
Questions / 100 Weightage
7. Data Structures & Algorithms 11–13 ≈12% Consistently the single
highest or co-highest
unit; graph algorithms
and recurrence-based
questions have grown.
5. System Software & OS 10–12 ≈12% Process scheduling,
deadlocks and memory
management (esp.
paging/TLB numericals)
are evergreen.
4. DBMS 11–13 ≈12% SQL/normalisation/
concurrency remain
core; Big Data &
NoSQL definitional
items added since
≈2019–20.
9. Computer Networks & Data 9–11 ≈10% OSI/TCP-IP layering
Communication and
addressing/subnetting
are staples; security
and cloud/IoT items
increasing since 2024.
8. Theory of Computation & 9–11 ≈10% Automata/CFG
Compilers questions slightly
outweigh compiler-
phase questions;
parsing (LL/LR) recurs.
1. Discrete Structures & 8–10 ≈9% Graph theory and
Optimization counting/probability
dominate;
Optimisation/PERT-
CPM sub-topics are
newer additions,
currently 1–3 Qs.
3. Programming Languages & 8–10 ≈9% C/C++/OOP
Computer Graphics fundamentals outweigh

Page 10
 UGC NET CS & Applications — Question Pattern Intelligence Report

Approx. Approx.
Unit Trend Note
Questions / 100 Weightage
graphics; line/circle-
drawing algorithms and
2D transforms recur in
graphics share.
2. Computer System Architecture 7–9 ≈8% Number systems,
pipelining and memory
hierarchy (cache/TLB)
are the recurring core;
digital logic design
questions are steady.
6. Software Engineering 6–8 ≈7% SDLC models,
COCOMO estimation
and testing types
(white-box/black-box,
alpha/beta) recur most.
10. Artificial Intelligence 5–7 ≈6% Search algorithms (A*,
minimax/alpha-beta)
and knowledge
representation recur
most; ML items
sometimes overlap with
DBMS data-mining sub-
topics.
Two patterns stand out from this table. First, the four units flagged in the executive summary
(DS&Algorithms, OS, DBMS, Networks) together sit at roughly 45–48 questions — just under
half the paper — and have held that share across every cycle since the 2019 syllabus took
effect. Second, the three “lighter” units (Software Engineering, AI, and the graphics portion of
Unit 3) are also the most theory-recall-heavy, meaning they reward broad familiarity with
definitions and classifications more than deep numerical practice — a good place to pick up
reliable marks with comparatively less study time.

Page 11
 UGC NET CS & Applications — Question Pattern Intelligence Report

Section 4 — The Seven “Wrappers”: How a Concept

Becomes a Question
A core idea behind this report is that the underlying concept pool is small and stable, but the
wrapper around it varies. The same fact about, say, page-replacement algorithms can be tested
as a one-line recall question, an assertion-reason pair, or a multi-statement true/false set,
depending on the cycle. Recognising the wrapper quickly — separately from the underlying
concept — saves time in the exam and focuses revision on concepts rather than memorising
phrasing. The seven wrappers below are illustrative templates constructed for this report to
show the pattern; they are not reproductions of any actual exam question.

Wrapper 1 — Direct Conceptual / Definitional

The plainest form: a single statement or definition with four options, one correct. Most common
for AI, Software Engineering, and “newly added” Big Data/Cloud/Optimisation topics.
Illustrative template: “Which of the following best describes [concept]?” followed by four candidate
definitions, only one of which is precisely correct.

Wrapper 2 — Match the Following

Two columns — typically List I (concepts/terms) and List II (definitions, formulas, or
classifications) — with answer options giving different pairings. Extremely common for
algorithm-to-complexity mappings, protocol-to-layer mappings, and normal-form-to-definition
mappings.
Illustrative template: List I = {Bubble Sort, Merge Sort, Quick Sort (worst case), Binary Search} and List II
= {O(n log n), O(n²), O(log n), O(n²)} — candidates match each algorithm to its correct complexity, with
the four options offering different correct/incorrect pairings.

Wrapper 3 — Assertion–Reason (A–R)

Two statements are given — an Assertion (A) and a Reason (R) — and candidates must judge
(i) whether each is individually true or false, and (ii) if both are true, whether R correctly explains
A. This format has become markedly more common from 2023 onward and was reported as the
dominant question type in the December 2025 Computer Science paper.
Illustrative template: ‘Assertion (A): A binary search tree’s in-order traversal produces elements in sorted
order. Reason (R): In-order traversal visits the left subtree, then the root, then the right subtree.’ Options
ask whether both A and R are true and whether R is the correct explanation of A, both true but R not
explaining A, A true/R false, or both false.

Wrapper 4 — Multi-Statement True/False Sets

Three to five short statements (often labelled I, II, III, IV) are given, and the options ask which
combination is correct (e.g. “I and III only,” “II, III and IV only”). This format is efficient for setters
because it lets one underlying topic generate many “facts,” several of which can be subtly
wrong.
Illustrative template: ‘Consider the following statements about TCP: (I) TCP provides connection-oriented
service. (II) TCP guarantees in-order delivery. (III) TCP uses a fixed window size throughout a
connection. (IV) TCP’s three-way handshake uses SYN and ACK flags. Which of the statements given
above are correct?’

Page 12
 UGC NET CS & Applications — Question Pattern Intelligence Report

Wrapper 5 — Sequential / Chronological Ordering

Candidates arrange a set of steps, events, or stages into the correct order — common for
process lifecycles, network communication sequences (e.g. DNS resolution → TCP handshake
→ HTTP request → response), compiler phases, and software process model stages.
Illustrative template: ‘Arrange the following compiler phases in the order in which they occur: (a) Code
Generation, (b) Lexical Analysis, (c) Syntax Analysis, (d) Semantic Analysis. Choose the correct
sequence.’

Wrapper 6 — Numerical / Calculation-Based

A short scenario with given values, requiring a calculation — cache hit/miss ratios, TLB address
translation, page-replacement frame counts, CPU-scheduling turnaround/waiting times,
subnetting/host counts, TCP sequence-number or bandwidth-delay calculations, and recurrence
relations solved via the Master theorem. These tend to be the most time-consuming questions
and are the ones most directly adapted from GATE-style problems.
Illustrative template: ‘A system uses a page size of 4 KB with a 32-bit virtual address. If the TLB has 16
entries, how many bits are required for the page offset, and how many bits remain for the page number?’

Wrapper 7 — Code / Output-Tracing

A short C/C++ code snippet (rarely more than 10–15 lines) is given, and candidates determine
the output, the number of times a loop executes, or the value of a variable after execution —
most common in Unit 3 (Programming Languages).
Illustrative template: a short snippet using pointers, recursion, or a for-loop with a non-trivial increment,
asking ‘What is the output of the above program?’ or ‘How many times is the function called?’

Across 2023–2026 papers, Wrappers 3 and 4 (assertion-reason and multi-statement sets) have
become the dominant formats for the core units, Wrapper 5 (sequencing) appears reliably for
process/network/compiler-lifecycle topics, and Wrapper 6 (numericals) remains concentrated in
OS, computer organisation, networks, and algorithms. Wrappers 1 and 2 remain the default for
Software Engineering, AI, and newly added topics.

Page 13
 UGC NET CS & Applications — Question Pattern Intelligence Report

Section 5 — Unit-by-Unit Hot List: The Sub-Topics That

Keep Reappearing
This section drills into each of the 10 units and lists the specific sub-topics that recur most
consistently across cycles, along with the wrapper format(s) they are most often tested in (using
the numbering from Section 4). Use this as a checklist: if you can confidently answer a question
on every row below in any of its listed formats, you are covering the part of the syllabus that
historically yields the most marks per hour of study.

Unit 1 — Discrete Structures and Optimization

Hot Sub-Topic Typical Question Angle
Propositional/predicate logic, normal forms Wrapper 1/4 — statement-based truth-value
(CNF/DNF) questions
Sets & relations — equivalence relations, Wrapper 1/2 — definitional and matching
partial orders, lattices
Counting — permutations, combinations, Wrapper 6 — short numericals
pigeonhole principle
Graph theory — Euler/Hamiltonian paths, Wrapper 6 — numerical/identification
planar graphs, graph colouring, spanning trees
Group theory — groups, subgroups, rings, Wrapper 1/4 — property-checking statements
fields (definitions & properties)
Boolean algebra — K-map / SOP-POS Wrapper 6 — simplify-the-expression numericals
simplification
Optimisation (new) — LPP formulation, Wrapper 1/6 — currently mostly definitional,
Simplex basics, PERT-CPM critical path occasional simple numerical

Unit 2 — Computer System Architecture

Hot Sub-Topic Typical Question Angle
Number systems — 1’s/2’s complement, IEEE Wrapper 6 — conversion/arithmetic numericals
floating-point representation
Cache memory — mapping techniques, write- Wrapper 3/6 — assertion-reason and hit-ratio
through vs write-back, hit ratio numericals
TLB & virtual memory address translation Wrapper 6 — bit-split numericals
Pipelining — hazards, speedup, throughput Wrapper 4/6 — statement sets and speedup
calculations
Addressing modes & instruction formats, RISC Wrapper 2/4 — matching and true/false sets
vs CISC
Multiprocessor organisation & cache Wrapper 1 — definitional
coherence basics

Page 14
 UGC NET CS & Applications — Question Pattern Intelligence Report

Unit 3 — Programming Languages and Computer Graphics

Hot Sub-Topic Typical Question Angle
C — pointers, arrays, recursion, storage Wrapper 7 — code/output tracing
classes (output/behaviour)
OOP concepts — inheritance, polymorphism, Wrapper 1/4 — definitional and statement sets
virtual functions, abstract classes
C++ — constructors/destructors, operator Wrapper 2 — matching feature to behaviour
overloading, templates
Line/circle drawing — DDA and Bresenham Wrapper 6 — step-count or pixel-position numericals
algorithms
2D transformations — translation, scaling, Wrapper 6 — matrix-based numericals
rotation matrices, composite transforms
Clipping algorithms (Cohen-Sutherland) & Wrapper 1/5 — conceptual/sequencing
viewing pipeline
Web basics — HTML/DHTML/XML/scripting Wrapper 1 — definitional
terminology

Unit 4 — Database Management Systems

Hot Sub-Topic Typical Question Angle
Functional dependencies, Armstrong’s axioms, Wrapper 3/6 — assertion-reason and FD-inference
attribute closure, candidate keys numericals (one of the single most repeated DBMS
topics)
Normalisation — 1NF through BCNF, lossless Wrapper 4/6 — statement sets and decomposition
join & dependency preservation checks
SQL — joins, nested/correlated queries, Wrapper 1/7 — direct query-result questions
aggregate & group-by, views, triggers
Relational algebra & calculus expressions Wrapper 2 — expression-to-meaning matching
Concurrency control — conflict serializability, Wrapper 6 — serializability/precedence-graph
precedence graphs, locking protocols numericals
Indexing — B-tree / B+ tree structure and Wrapper 1/6 — structural and order-calculation
operations questions
Data warehousing/mining — OLAP vs OLTP, Wrapper 1/2 — definitional and matching
classification, clustering, association rules
Big Data & NoSQL (new) — Wrapper 1 — mostly definitional for now
Hadoop/HDFS/MapReduce terminology,
NoSQL types (key-value, document, column,
graph)

Page 15
 UGC NET CS & Applications — Question Pattern Intelligence Report

Unit 5 — System Software and Operating System

Hot Sub-Topic Typical Question Angle
Process states & context switching — which Wrapper 3/5 — assertion-reason and sequencing
events force a state change (one of the most repeated OS topics)
CPU scheduling — FCFS, SJF, Priority, Wrapper 6 — Gantt-chart-style numericals
Round Robin (turnaround/waiting time)
Deadlocks — conditions, Wrapper 4/6 — statement sets and resource-
prevention/avoidance, Banker’s algorithm, allocation numericals
detection
Memory management — paging, Wrapper 6 — page-fault-count numericals
segmentation, page-replacement
(LRU/FIFO/Optimal), thrashing
Disk scheduling — FCFS, SSTF, SCAN, C- Wrapper 6 — total-seek-distance numericals
SCAN (seek time)
Process synchronisation — semaphores, Wrapper 1/7 — conceptual and short pseudo-code
Peterson’s solution, producer-consumer/critical
section
Linux/Windows internals — kernel modules, Wrapper 1 — definitional
file systems, system calls

Unit 6 — Software Engineering

Hot Sub-Topic Typical Question Angle
SDLC/process models — Waterfall, Spiral, Wrapper 2/4 — matching models to characteristics,
Incremental, Agile (Scrum/XP) true/false sets
Requirements — functional vs non-functional, Wrapper 1/4 — classification statements
use cases, SRS structure
Estimation — LOC/FP-based estimation, Wrapper 6 — effort/cost calculation numericals
COCOMO model
Software design principles — cohesion, Wrapper 1/2 — definitional and matching
coupling, modularity, architectural styles
Testing — unit/integration/system, white-box Wrapper 2/4 — matching test type to purpose
vs black-box, alpha/beta, regression
Quality & metrics — McCall’s factors, ISO Wrapper 1 — definitional
9126, RMMM (risk management)

Unit 7 — Data Structures and Algorithms

Hot Sub-Topic Typical Question Angle
Tree structures — BST operations, AVL Wrapper 6 — structural/height numericals
rotations, B-tree/B+ tree order
Graph traversal — BFS vs DFS (applications, Wrapper 2/4 — comparison and application-

Page 16
 UGC NET CS & Applications — Question Pattern Intelligence Report

Hot Sub-Topic Typical Question Angle

traversal order) matching (extremely common)
Minimum spanning trees — Prim’s and Wrapper 6 — step-by-step construction numericals
Kruskal’s algorithms vs shortest-path (Dijkstra)
Sorting/searching — best/average/worst-case Wrapper 2 — algorithm-to-complexity matching
complexity comparisons
Recurrence relations — Master theorem cases Wrapper 6 — solve-the-recurrence numericals (very
for T(n)=aT(n/b)+f(n) high yield)
Algorithm design paradigms — greedy vs DP Wrapper 4 — statement sets classifying problems
vs divide-and-conquer classification
P vs NP, NP-completeness, reducibility Wrapper 1 — conceptual definitional

Unit 8 — Theory of Computation and Compilers

Hot Sub-Topic Typical Question Angle
DFA/NFA construction & equivalence, Wrapper 6/1 — construct-or-identify questions
minimisation
Regular expressions, pumping lemma, regular Wrapper 1/4 — property statements
vs non-regular languages
Context-free grammars — derivations, Wrapper 1/6 — ‘which language does this CFG
ambiguity, Chomsky/Greibach normal forms generate’ style
CFL closure properties Wrapper 4 — true/false property sets (very high
(union/concatenation/Kleene star vs yield)
intersection/complement)
Pushdown automata & equivalence with CFGs Wrapper 1 — conceptual
Turing machines, decidability, halting problem, Wrapper 1/4 — classification statements
Chomsky hierarchy
Parsing — LL(1), LR/SLR/LALR table Wrapper 6 — table/derivation numericals
construction and conflicts
Compiler phases & intermediate code Wrapper 5 — sequencing questions
generation order

Unit 9 — Data Communication and Computer Networks

Hot Sub-Topic Typical Question Angle
OSI vs TCP/IP layers — protocol-to-layer Wrapper 2 — matching (extremely common)
mapping
IP addressing & subnetting — Wrapper 6 — subnetting numericals (high yield)
classful/classless, CIDR, host/subnet counts
Error detection/correction — CRC, checksum, Wrapper 6 — calculation numericals
Hamming code

Page 17
 UGC NET CS & Applications — Question Pattern Intelligence Report

Hot Sub-Topic Typical Question Angle

TCP/UDP — three-way handshake, flow & Wrapper 3/6 — assertion-reason and
congestion control, sequence numbers bandwidth/sequence-number numericals
Routing — distance-vector vs link-state, Wrapper 1/4 — conceptual/statement sets
common algorithms
Application layer — DNS resolution, HTTP Wrapper 5 — chronological-ordering of a
request flow, email protocols web/communication sequence
(SMTP/POP/IMAP)
Network security — symmetric vs asymmetric Wrapper 1/2 — definitional and matching
cryptography, digital signatures,
firewalls/VPNs
Cloud & IoT (new) — SaaS/PaaS/IaaS Wrapper 1 — mostly definitional for now
distinctions, basic IoT architecture terms

Unit 10 — Artificial Intelligence

Hot Sub-Topic Typical Question Angle
Search strategies — BFS/DFS/A* and Wrapper 2/6 — matching and path-cost numericals
heuristic comparisons
Game playing — Min-Max search and Alpha- Wrapper 6 — value-computation numericals
Beta pruning
Knowledge representation — semantic Wrapper 1/2 — definitional and matching
networks, frames, predicate logic, ontologies
Planning — STRIPS, goal-stack and Wrapper 1 — definitional
hierarchical planning terminology
Fuzzy sets — membership functions, Wrapper 6 — set-operation numericals
fuzzification/defuzzification, fuzzy operations
Genetic algorithms — encoding, Wrapper 1 — conceptual
crossover/mutation, fitness function
terminology
Artificial neural networks — perceptron, Wrapper 1/4 — classification statements
learning types
(supervised/unsupervised/reinforcement)

Page 18
 UGC NET CS & Applications — Question Pattern Intelligence Report

Section 6 — Reading the Tea Leaves: Prediction for the

Upcoming Cycle
UGC NET is conducted twice a year (a June session and a December/January session), and
the syllabus, format mix and unit weightages have been remarkably stable across the most
recent cycles. The December 2025 paper (held 2 January 2026) was reported as moderate-to-
tough, dominated by assertion-reason questions with frequent chronological-ordering items and
a heavy concentration on Data Structures, Algorithms, OS, DBMS, Networks and Theory of
Computation — reinforcing the patterns identified throughout this report. Based on that
trajectory, the table below sets out a tier-based forecast for the next cycle(s).

6.1 Tier-Based Forecast

Tier Approx. Marks What to Expect
Tier 1 — Near- ≈80–90 marks Functional dependencies & normalisation (DBMS); process
Certain Core (40–45 Qs) scheduling, deadlocks & memory management with numericals
(OS); graph algorithms — BFS/DFS/MST (DS&A); recurrence
relations via Master theorem (Algorithms); OSI/TCP-IP layer
mapping & subnetting (Networks); CFG/regular-language
closure properties (TOC). Expect these mainly in assertion-
reason and multi-statement true/false wrappers.
Tier 2 — Highly ≈60–70 marks Cache/TLB and pipelining numericals (Computer Architecture);
Likely (30–35 Qs) discrete-math graph theory and counting (Unit 1 core); C/C++
Secondary Core output-tracing and OOP concepts, plus 2D-transform/line-
drawing numericals (Unit 3); SDLC models, COCOMO and
testing-type matching (Software Engineering); LL/LR parsing
and compiler-phase sequencing (Unit 8).
Tier 3 — Likely ≈30–40 marks Classical AI — search algorithms, Min-Max/Alpha-Beta,
but Lower (15–20 Qs) knowledge representation, fuzzy sets, ANN basics; network
Density security and application-layer sequencing; data
warehousing/mining classification & clustering terms.
Tier 4 — ≈10–15 marks Optimisation/Operations Research — LPP formulation, Simplex
Emerging / (5–8 Qs) basics, PERT-CPM critical path (Unit 1, 2024 addition); Big
Watch-List Data/Hadoop/NoSQL terminology (Unit 4 addition); Cloud
computing (SaaS/PaaS/IaaS) and IoT basics (Unit 9 addition).
These are the topics most likely to surprise candidates who are
studying from pre-2024 material.

6.2 Format Forecast

Expect assertion-reason and multi-statement true/false sets to remain the dominant wrappers
for the four core units, chronological-ordering questions for process/network/compiler
sequences, and numerical questions concentrated in OS, computer organisation, networks and
algorithms — generally 25–30% of the paper. Pure one-line definitional recall is increasingly
reserved for Software Engineering, AI, and the Tier 4 emerging topics, where the question bank
is still relatively shallow.

Page 19
 UGC NET CS & Applications — Question Pattern Intelligence Report

6.3 The Single Highest-Leverage Move

If only one preparation action can be taken from this entire report, it is this: build a personal
‘rotation log’ of the Tier 1 and Tier 2 sub-topics across the last 6–8 cycles, noting (a) the
underlying fact tested and (b) the wrapper used each time. Because the underlying fact pool for
these units is small and the wrapper rotates in a fairly limited cycle (definitional → matching →
assertion-reason → statement-set → back to definitional with new numbers), this log will let you
anticipate not just what will be asked, but roughly how it will be asked — which is most of the
battle in a time-pressured, no-negative-marking objective exam.

Page 20
 UGC NET CS & Applications — Question Pattern Intelligence Report

Section 7 — Turning the Analysis into a Preparation Plan

This plan converts the tiering from Section 6 into a time-allocation framework. It assumes a
study runway of roughly 8–10 weeks before an exam; if your timeline is shorter, compress
proportionally but keep the relative emphasis — Tier 1 first, always.

7.1 Time Allocation by Tier

Suggested Share of
Tier Primary Activity
Study Time
Tier 1 (core four units) ≈45% Concept mastery from the canonical
textbook for each unit (Section 2.1),
then 8–10 cycles of PYQs on each
Tier-1 sub-topic, tracked in a rotation
log (Section 6.3).
Tier 2 (secondary core) ≈30% Concept notes + 5–6 cycles of PYQs;
prioritise numerical practice for
Computer Architecture and the
programming/graphics calculation
types.
Tier 3 (lighter units) ≈15% Definition and classification tables
(SDLC models, AI search strategies,
testing types) — high recall value for
relatively low time investment.
Tier 4 (emerging topics) ≈10% Read the 2024 syllabus addendum
carefully (Optimisation/PERT-CPM,
Big Data/NoSQL, Cloud/IoT); master
definitions and one worked numerical
example each (e.g. one Simplex
iteration, one CPM critical-path
calculation) since deeper numericals
are not yet common but basic ones
are emerging.

7.2 A Practical Weekly Rhythm

4. Two units of new-concept study per week from the canonical textbook list, prioritised by
the order in Section 3 (highest-weightage units first).
5. One PYQ-rotation session per unit covering 2013–2025 (or as many cycles as
available), specifically logging the underlying concept and the wrapper format used —
not just the answer.
6. One GATE-CSE practice session per week on whichever Tier-1/Tier-2 sub-topic is
numerically heaviest that week (cache/TLB, scheduling, subnetting, recurrences,
MST/shortest path).
7. One full-length mock test every 1–2 weeks, reviewed specifically for wrapper-format
misses (e.g. ‘I knew the fact but mis-read the assertion-reason logic’) — this is a
different failure mode from ‘I didn’t know the fact’ and needs different practice.

Page 21
 UGC NET CS & Applications — Question Pattern Intelligence Report

8. In the final 1–2 weeks, a dedicated pass over Tier 4 emerging topics so they are not left
as complete unknowns on exam day.

7.3 Quick-Reference Checklist

• Have I solved at least 8 cycles of PYQs for each Tier-1 sub-topic in Section 5, not just
the most recent one or two?
• For each core unit, do I know which canonical textbook (Section 2.1) its hardest
questions are likely paraphrased from, and have I worked through that book’s solved
examples for the high-frequency sub-topics?
• Can I solve a Master-theorem recurrence, a TLB/cache numerical, a subnetting problem,
and a CPU-scheduling Gantt chart within 60–90 seconds each?
• Have I specifically practised assertion-reason and multi-statement true/false questions
— not just ‘knowing the topic’ but the logic of these formats themselves?
• Have I covered the 2024 syllabus additions (Optimisation/PERT-CPM, Big Data/NoSQL,
Cloud/IoT) at least at definitional level?

Page 22
 UGC NET CS & Applications — Question Pattern Intelligence Report

Section 8 — Methodology, Sources & Important Caveats

8.1 How This Report Was Built
This report synthesises (a) the official UGC NET Computer Science & Applications syllabus
structure as published for the current cycles, (b) publicly available unit-wise weightage analyses
produced by UGC NET coaching platforms and educators based on multi-year PYQ review, (c)
recently published exam-pattern and difficulty analyses for the 2025–2026 cycles, and (d)
standard mappings between the syllabus sub-topics and the canonical computer-science
textbooks those sub-topics are drawn from. Where sources gave overlapping but slightly
different weightage figures, this report presents consolidated ranges rather than a single precise
number.

8.2 What This Report Is — and Is Not

• It is: a structured, evidence-informed guide to where Paper II marks have historically
concentrated, why the syllabus is organised the way it is, how questions are typically
‘wrapped,’ and which topics are most likely to be emphasised in the near term given
recent syllabus changes and recent exam-analysis reports.
• It is not: an official NTA/UGC publication, a guarantee of what will appear in any specific
paper, or a substitute for working through actual previous-year question papers and the
canonical textbooks themselves. NTA does not publish official per-unit weightages, and
any individual cycle can deviate from historical patterns.
• Treat probabilities as guidance, not certainty: the value of this report is in
prioritisation — spending limited study time where it has historically paid off most — not
in narrowing preparation to only the topics listed here.

8.3 Suggested Next Steps

To turn this report into action: (1) download the actual UGC NET Computer Science Paper II
question papers and answer keys for as many cycles from 2013 to 2025 as are available from
the official NTA archive or established educational platforms; (2) for each Tier-1 and Tier-2 sub-
topic in Section 5, pull out every instance of that sub-topic across those papers and build the
‘rotation log’ described in Section 6.3; (3) cross-reference any unfamiliar or unusually specific
question against the canonical textbook for that unit (Section 2.1) to understand its likely origin;
and (4) revisit the Tier 4 watch-list (Section 6.1) periodically, since these are the sub-topics most
likely to shift in weight as the 2024 syllabus additions mature.
Good luck with your preparation.

Page 23