M.Sc. in CSE · Admission Test · CUET pattern (BUET / KUET / JU PMSCS aligned)

The Complete Study Book

Everything the M.Sc. (CSE) admission MCQ + short-written exam draws from — every subject, every definition explained in plain language with an example, every high-yield fact marked. Built from real question banks (JU PMSCS "Father of Admission Test", Examveda computer bank, BUET/KUET past patterns). Analysis of those banks: ~80% of questions come from CSE core subjects, ~20% from math, analytical reasoning and English.

Exam date20 July 2026

FormatMCQ + short written (compare / define / small math)

Reading time~6–8 hours, then revise the rapid-fire lists daily

Contents · weight = how heavily it appears in past papers

C Programming & OOP — very high
Data Structures & Algorithms — very high
Operating Systems — very high
DBMS & SQL — very high
Computer Networks — high
Digital Logic Design — high
Computer Architecture & 8086 — high
Discrete Mathematics — medium
Software Engg. & Compiler — medium
Quantitative Aptitude — 20% section
Analytical Reasoning — 20% section
English Essentials — 20% section
Written Part: Compare & Define — guaranteed marks
Rapid-Fire Fact Bank + Full Forms — last-day revision
15-Day Plan & Exam-Day Strategy

Chapter 01

C Programming & OOP

Weight: very high — output-prediction MCQs are guaranteed

1.1 The facts examiners love

C developed by: Dennis Ritchie, 1972, Bell Labs (for UNIX).

C++ developed by: Bjarne Stroustrup. Java: James Gosling (Sun Microsystems).

C is a structured / procedural, middle-level, compiled language.

Program execution starts from main().

Compiler translates whole program at once; interpreter line by line.

Keywords in C: 32. All lowercase.

sizeof is an operator, not a function.

Typical sizes (32/64-bit gcc): char = 1, int = 4, float = 4, double = 8, pointer = 8 (on 64-bit).

Array index starts at 0; last index = size − 1.

String terminator: '\0' (null character). So "CSE" takes 4 bytes.

Format specifiers: %d int, %f float, %lf double, %c char, %s string, %x hex, %o octal, %p pointer, %u unsigned.

Header for printf/scanf: stdio.h; strings → string.h; math → math.h; malloc → stdlib.h.

1.2 Definitions you must be able to write

Definition — Variable A named memory location whose value can change during program execution. Example: int marks = 80; reserves 4 bytes named marks holding 80.

Definition — Pointer A variable that stores the memory address of another variable. Example: int a=5; int *p=&a; — now *p gives 5 (value at that address), p gives the address. & = "address of", * = "value at".

Definition — Recursion A function calling itself, with a base case that stops the calls. Example: factorial — fact(n) = n * fact(n-1), base case fact(0)=1. Recursion uses the stack; missing base case → stack overflow.

Definition — Static variable A variable that is initialized only once and keeps its value between function calls; default value 0. Example: a counter inside a function that remembers how many times the function ran.

Storage classes (one-line each)

Class	Stored in	Default value	Lifetime / scope
`auto`	RAM (stack)	garbage	inside block only (default for locals)
`register`	CPU register (request)	garbage	fast access; cannot take its address with &
`static`	RAM (data segment)	0	whole program run, keeps value between calls
`extern`	RAM	0	global, visible across files

1.3 Output-prediction traps (the exact patterns asked)

Trap 1 — i++ vs ++i i++ uses the value first, then increments; ++i increments first. Example: int i=5; printf("%d %d", i++, ++i); is undefined behaviour in one printf, but the classic single case: i=5; x=i++; → x=5, i=6. i=5; x=++i; → x=6, i=6.

Trap 2 — Integer division 5/2 = 2 (not 2.5), because both are int. 5.0/2 = 2.5. 5%2 = 1 (remainder). % works only on integers.

Trap 3 — Assignment inside if if(a = 0) assigns 0 → condition false. if(a == 0) compares. Any non-zero value is true in C; 0 is false.

Trap 4 — float comparison & char arithmetic 'A' has ASCII value 65, 'a' = 97, '0' = 48. So 'A'+1 prints 66, or 'B' with %c. Difference between uppercase and lowercase = 32.

Trap 5 — Array name is an address For int a[5], a itself is the address of a[0]. *(a+2) is the same as a[2]. Pointer arithmetic moves by the size of the type: for int pointer, p+1 jumps 4 bytes.

Worked example — trace this

int a = 10, b;
b = a++ + ++a;   // a++ gives 10 (a becomes 11), ++a makes a=12 and gives 12
printf("%d %d", a, b);   // prints: 12 22

Trace left to right, updating the variable at each step. Most output MCQs die to careful tracing.

Loop counting pattern

Example for(i=0;i<10;i+=2) runs for i = 0,2,4,6,8 → 5 times. Formula: number of runs = ⌈(end − start)/step⌉. while(1) and for(;;) are infinite loops. break exits the loop; continue skips to the next iteration.

1.4 Strings and common library functions

Function	Does	Example
`strlen(s)`	length WITHOUT '\0'	strlen("CUET") = 4
`strcpy(d,s)`	copy s into d	—
`strcat(d,s)`	join s to end of d	"AB"+"CD" → "ABCD"
`strcmp(a,b)`	0 if equal, <0 if a<b, >0 if a>b (dictionary order)	strcmp("abc","abc")=0
`strrev(s)`	reverse (non-standard, Turbo C)	—

1.5 Memory functions

Definition — malloc vs calloc Both allocate memory at run time (dynamic allocation, from the heap). malloc(n) allocates n bytes with garbage values; calloc(k, size) allocates k blocks and initializes to 0. realloc resizes; free() releases. Forgetting free() → memory leak.

1.6 OOP — the four pillars (asked constantly)

Pillar	Plain meaning	Real example
Encapsulation	Wrap data + functions together in a class; hide data with `private`	Bank account: balance is private, you change it only through deposit()/withdraw()
Abstraction	Show only what is needed, hide how it works	You press the brake pedal; you don't see the hydraulics
Inheritance	A new class reuses properties of an existing class	class Car inherits from class Vehicle
Polymorphism	Same name, different behaviour	function overloading (compile-time), virtual function overriding (run-time)

Class = blueprint; object = real instance of the class.

Constructor: special function, same name as class, no return type, runs automatically when object is created. Destructor (~ClassName) runs when object is destroyed.

Constructor overloading = multiple constructors with different parameters.

Compile-time polymorphism: function/operator overloading. Run-time: virtual functions (achieved via pointers/late binding).

Java: platform independent ("write once run anywhere") because it compiles to bytecode run by the JVM. No pointers, no multiple inheritance of classes (uses interfaces).

Java: everything must be inside a class. Entry: public static void main(String[] args).

Access specifiers: private (class only), protected (class + derived), public (everywhere). Default in C++ class = private; in struct = public.

friend function can access private members of a class without being a member.

this pointer = address of the current object.

Chapter 02

Data Structures & Algorithms

Weight: very high — complexity table alone answers 4–6 MCQs

2.1 Big-O in one paragraph

Definition — Time complexity / Big-O Big-O tells how running time grows as input size n grows — the worst case. Example: searching an unsorted list checks up to n items → O(n). Binary search halves each time → O(log n). Growth order (slow → fast growth): O(1) < O(log n) < O(n) < O(n log n) < O(n²) < O(2ⁿ) < O(n!).

2.2 THE complexity table (memorize cold)

Algorithm	Best	Average	Worst	Extra note
Bubble sort	O(n)	O(n²)	O(n²)	swaps neighbours; stable
Selection sort	O(n²)	O(n²)	O(n²)	minimum swaps (n−1); not stable
Insertion sort	O(n)	O(n²)	O(n²)	best for nearly-sorted / small data; stable
Merge sort	O(n log n)	O(n log n)	O(n log n)	divide & conquer; needs O(n) extra space; stable
Quick sort	O(n log n)	O(n log n)	O(n²)	worst when already sorted / bad pivot; in-place; not stable
Heap sort	O(n log n)	O(n log n)	O(n log n)	in-place, not stable
Counting/Radix	O(n+k) / O(nk)			non-comparison sorts
Linear search	O(1)	O(n)	O(n)	works on unsorted data
Binary search	O(1)	O(log n)	O(log n)	data must be sorted
Hash table lookup	O(1)	O(1)	O(n)	worst = all keys collide
BST search/insert	O(log n) balanced		O(n) skewed	AVL guarantees O(log n)

মনে রাখো Comparison-based sorting cannot beat O(n log n) — that's the theoretical lower bound. Any MCQ saying a comparison sort runs in O(n) for all inputs is false.

2.3 Linear structures

Definition — Array vs Linked List An array stores elements in contiguous memory with fixed size — access by index is O(1), but insert/delete in the middle is O(n) (shifting). A linked list stores nodes anywhere in memory, each node holding data + pointer to the next — insert/delete is O(1) if you have the node, but access is O(n) (must walk from head). Example: a class attendance sheet with fixed roll numbers = array; a train where you can attach/detach bogies = linked list.

Definition — Stack (LIFO) Last-In-First-Out list; insert and delete happen at one end (the top). Operations: push, pop, peek. Example: a stack of plates. Uses: function calls (recursion), undo, expression evaluation, infix→postfix conversion, balanced-parentheses check, DFS. Push on full stack = overflow; pop on empty = underflow.

Definition — Queue (FIFO) First-In-First-Out; insert at rear, delete at front. Example: ticket line. Uses: CPU/printer scheduling, BFS. Variants: circular queue (rear wraps around to reuse space), deque (insert/delete both ends), priority queue (highest priority out first — implemented with a heap).

Worked example — Postfix evaluation (classic MCQ) Infix A + B * C → postfix A B C * + (because * has higher precedence). Evaluate postfix 6 2 3 + - 3 8 2 / + *: 2+3=5 → 6−5=1 → 8/2=4 → 3+4=7 → 1*7 = 7. Rule: scan left→right, push operands, on operator pop two (second-popped OP first-popped), push result.

2.4 Trees

Definition — Binary tree A tree where each node has at most 2 children. Key formulas: max nodes at level i = 2ⁱ (root = level 0); max nodes in tree of height h = 2^(h+1) − 1; a binary tree with n nodes has n−1 edges; number of leaf nodes = internal-nodes-with-2-children + 1 in a full tree; minimum height with n nodes = ⌈log₂(n+1)⌉ − 1.

Definition — Binary Search Tree (BST) A binary tree where for every node: left subtree values < node < right subtree values. So inorder traversal of a BST gives sorted order — the single most-asked tree fact.

Worked example — Traversals Tree: root 50, left 30 (children 20, 40), right 70 (children 60, 80).
Inorder (L-Root-R): 20 30 40 50 60 70 80 (sorted ✔)
Preorder (Root-L-R): 50 30 20 40 70 60 80 — used to copy a tree
Postorder (L-R-Root): 20 40 30 60 80 70 50 — used to delete a tree
Level order: 50 30 70 20 40 60 80 — uses a queue (BFS).

Definition — AVL tree A self-balancing BST where for every node, |height(left) − height(right)| ≤ 1 (the balance factor ∈ {−1, 0, +1}). If insertion breaks the balance, we fix it with rotations: LL case → right rotation, RR → left rotation, LR → left then right, RL → right then left. Guarantees O(log n) search/insert/delete.

Definition — Heap A complete binary tree where every parent ≥ children (max-heap) or ≤ children (min-heap). Stored in an array: for index i, children at 2i+1 and 2i+2, parent at ⌊(i−1)/2⌋. Insert/delete = O(log n); getting max/min = O(1); building a heap from n items = O(n). Used for priority queues and heap sort.

2.5 Graphs

Definition — Graph A set of vertices (V) connected by edges (E). Directed (edges have direction) vs undirected. Representations: adjacency matrix (V×V, O(V²) space, edge check O(1)) vs adjacency list (O(V+E) space — better for sparse graphs).

	BFS	DFS
Data structure	Queue	Stack / recursion
Explores	level by level (nearest first)	as deep as possible first
Finds shortest path (unweighted)?	Yes	No
Complexity	O(V+E)	O(V+E)
Uses	shortest path, level order	cycle detection, topological sort, maze solving

Definition — Dijkstra's algorithm Finds the shortest path from one source to all vertices in a weighted graph with non-negative weights. Greedy: repeatedly pick the unvisited vertex with the smallest known distance and relax its neighbours. Complexity O(E log V) with a min-heap. Fails on negative edges → use Bellman-Ford (O(VE), detects negative cycles). All-pairs shortest path → Floyd-Warshall O(V³).

Definition — Minimum Spanning Tree (MST) A spanning tree connects all V vertices using exactly V−1 edges with no cycle; the MST is the one with minimum total weight. Kruskal: sort all edges, add smallest that doesn't form a cycle (uses union-find). Prim: grow the tree from one vertex, always adding the cheapest edge leaving the tree. Both greedy, both O(E log V).

Definition — Hashing Mapping a key to an array index using a hash function, e.g. h(k) = k mod 10. Two keys mapping to the same index = collision. Resolutions: chaining (linked list per slot) and open addressing (linear probing: try next slot; quadratic probing; double hashing).

Algorithm design paradigms (asked as "X is an example of ___")

Paradigm	Idea	Examples
Divide & Conquer	split, solve, combine	merge sort, quick sort, binary search
Greedy	best local choice each step	Dijkstra, Prim, Kruskal, Huffman coding, fractional knapsack
Dynamic Programming	store answers to overlapping subproblems	Fibonacci (memoized), 0/1 knapsack, LCS, Floyd-Warshall
Backtracking	try, undo, try again	N-Queens, Sudoku, maze

মনে রাখো "0/1 knapsack → DP, fractional knapsack → Greedy" — a favourite trap pair.

Chapter 03

Operating Systems

Weight: very high — scheduling math + deadlock + paging appear every year

3.1 Core definitions

Definition — Operating System System software that sits between hardware and the user, managing all resources: CPU (process management), memory, files, I/O devices. It is the first program loaded after boot. Its core is the kernel — the memory-resident part. Examples: Windows, Linux (open-source, monolithic kernel), UNIX (Bell Labs/AT&T, 1970s), macOS (UNIX-based), Android (Linux-based).

Definition — Process vs Program vs Thread A program is a passive file on disk; a process is a program in execution (has its own memory, registers, PCB). A thread is a lightweight unit inside a process — threads of one process share code, data and files but have their own stack and registers. The OS stores each process's info in a Process Control Block (PCB): PID, state, program counter, registers, open files.

Definition — Booting Loading the OS into RAM. Steps: power on → BIOS (in ROM) runs POST (Power-On Self Test) → bootstrap loader loads the OS from disk into RAM → kernel starts. Warm boot = restart; cold boot = power off/on.

Process states (5-state model)

New → Ready → Running → (Waiting/Blocked ↔) → Terminated. Ready = waiting for CPU; Running = has CPU; Waiting = waiting for I/O. Moving CPU from one process to another = context switch (pure overhead — no useful work). The dispatcher gives the CPU to the process chosen by the scheduler; dispatch latency = time to stop one process and start another.

3.2 CPU Scheduling — with the math they ask

Algorithm	Type	Key property
FCFS (First Come First Served)	Non-preemptive	simple; suffers convoy effect (short jobs stuck behind long)
SJF (Shortest Job First)	Non-preemptive	optimal minimum average waiting time; risk of starvation of long jobs
SRTF (Shortest Remaining Time First)	Preemptive SJF	preempts if a shorter job arrives
Round Robin	Preemptive	each process gets a fixed time quantum; best for time-sharing; too-small quantum → too many context switches
Priority	Both	starvation fixed by aging (slowly raising priority of waiting jobs)

Worked example — FCFS & SJF average waiting time (do this by hand) Processes arrive at time 0 with burst times: P1=24, P2=3, P3=3.
FCFS order P1,P2,P3: waiting = 0, 24, 27 → average = (0+24+27)/3 = 17 ms.
SJF order P2,P3,P1: waiting = 0, 3, 6 → average = (0+3+6)/3 = 3 ms.
Formulas: Waiting time = Turnaround − Burst; Turnaround = Completion − Arrival; Response time = first time it gets CPU − arrival.

Worked example — Round Robin (quantum = 4) P1=24, P2=3, P3=3, all arrive at 0. Gantt: P1(0–4) P2(4–7) P3(7–10) P1(10–14)…P1 finishes at 30. Waiting: P1 = 30−24 = 6, P2 = 4, P3 = 7 → average ≈ 5.67 ms.

3.3 Deadlock

Definition — Deadlock A set of processes each holding a resource and waiting for a resource held by another — nobody can proceed. Example: P1 holds the printer and wants the scanner; P2 holds the scanner and wants the printer.

The 4 necessary conditions (mnemonic: M-H-N-C, "মহনচ") Mutual exclusion · Hold and wait · No preemption · Circular wait. All four must hold simultaneously; break any one and deadlock is impossible.

Handling strategies: Prevention (deny one of the 4 conditions), Avoidance (Banker's algorithm — stay in a "safe state" by checking before granting), Detection & recovery (allow it, find cycle in resource-allocation graph, kill/rollback), Ignore (ostrich algorithm — what most OSes actually do).

3.4 Memory management & paging (favourite MCQ zone)

Definition — Paging Divide a process into fixed-size pages and physical memory into same-size frames; any page can go into any frame, so no external fragmentation (but there is internal fragmentation — unused space inside the last page). The page table maps page number → frame number. Segmentation instead divides by logical units (code, stack…) of variable size → external fragmentation.

Definition — Virtual memory & demand paging The illusion of a very large main memory, made by keeping part of the process on disk (the swap file on the hard drive) and bringing a page into RAM only when it is needed (demand paging). If the CPU touches a page not in RAM → page fault → OS loads it from disk. Too many page faults so the system spends all its time swapping = thrashing; fixed using the working set model.

Worked example — Page replacement, 3 frames, reference string 1,2,3,4,1,2,5,1,2,3,4,5 FIFO: 9 faults. LRU (replace least-recently-used): 10 faults. Optimal (replace the page needed farthest in future — theoretical best): 7 faults. Belady's Anomaly: with FIFO, adding MORE frames can sometimes cause MORE page faults (this string gives 9 faults with 3 frames but 10 with 4). LRU and Optimal never show this.

Definition — Fragmentation & fits External: free memory exists but in scattered pieces (fix: compaction — merge small holes into one big hole). Internal: wasted space inside an allocated block. Allocation strategies: First fit (first hole big enough), Best fit (smallest adequate hole), Worst fit (largest hole).

3.5 Synchronization

Definition — Critical section & Semaphore The critical section is code that accesses shared data — only one process may be inside at a time. A semaphore is an integer variable controlling access via two atomic operations: wait(P) decrements (blocks if 0) and signal(V) increments. Two types: binary semaphore (0/1, works like a mutex/lock) and counting semaphore (N identical resources). Classic problems: Producer–Consumer, Readers–Writers, Dining Philosophers.

Definition — Interrupt vs Spooling An interrupt is a signal from a device needing immediate CPU attention (e.g. keystroke). Spooling (Simultaneous Peripheral Operations On-Line) queues jobs — e.g. the print queue — so a slow device doesn't block the CPU.

OS types (one-liners)

Batch OS: jobs grouped and run without interaction.

Time-sharing / multitasking: CPU switches rapidly among many tasks (Round Robin).

Real-time OS: response time is crucial — e.g. car fuel injection, missile guidance, process control.

Multiprogramming: many programs in memory to keep the CPU busy. Multiprocessing: more than one CPU.

Embedded OS: inside devices — mobile phones, thermostats.

MS-DOS: single-user, single-tasking, command-driven — NOT truly multitasking.

File systems: DOS→FAT16, Win95→FAT32, WinNT/2000/modern→NTFS (New Technology File System). Linux→ext4.

Deleting with Shift+Delete skips the Recycle Bin. One recycle bin per drive/partition.

Chapter 04

DBMS & SQL

Weight: very high — normalization + SQL query + ACID guaranteed

4.1 Foundations

Definition — Database & DBMS A database is an organized collection of related data; a DBMS is software to create, store, query and control it (MySQL, Oracle, PostgreSQL, SQL Server). Advantages over file systems: less redundancy, no inconsistency, shared access, security, backup. The relational model was proposed by E.F. Codd (1970).

Definition — Relation, tuple, attribute, degree, cardinality In the relational model a table = relation, a row = tuple, a column = attribute. Degree = number of columns; cardinality = number of rows. Schema = design/structure; instance = data at a moment.

Keys (a guaranteed MCQ)

Key	Meaning	Example (Student table)
Super key	any attribute set that uniquely identifies a row	{Roll}, {Roll, Name}
Candidate key	minimal super key	{Roll}, {NID}
Primary key	chosen candidate key; unique + NOT NULL, one per table	Roll
Alternate key	candidate keys not chosen	NID
Foreign key	attribute referring to the primary key of another table — creates the link; can be NULL/duplicate	Dept_ID in Student → Dept table
Composite key	key made of 2+ attributes	{CourseID, Roll} in Enrollment

Definition — ER model Entity–Relationship diagram: rectangle = entity, ellipse = attribute, diamond = relationship, double ellipse = multivalued attribute, dashed ellipse = derived attribute (e.g. age from DOB), double rectangle = weak entity (no key of its own). Cardinalities: 1:1, 1:N, M:N.

4.2 Normalization — learn with ONE running example

Definition — Normalization Step-by-step decomposition of tables to remove redundancy and anomalies (insertion, update, deletion anomalies), based on functional dependencies. A functional dependency X → Y means: value of X determines value of Y.

Running example Table: Student(Roll, Name, Dept, DeptHead, Courses) where Courses holds "CSE101, CSE102".

1NF — atomic values only. "CSE101, CSE102" in one cell violates 1NF. Fix: one course per row (or a separate table). No repeating groups.
2NF — 1NF + no partial dependency. If key = {Roll, CourseID} but Name depends only on Roll (part of the key), that's partial dependency. Fix: split Student(Roll, Name…) and Enrollment(Roll, CourseID).
3NF — 2NF + no transitive dependency. Roll → Dept and Dept → DeptHead means Roll → DeptHead transitively. Fix: separate Dept(Dept, DeptHead) table.
BCNF — for every dependency X → Y, X must be a super key. Stricter 3NF.

Memory hook: 1NF atomic → 2NF partial gone → 3NF transitive gone → BCNF every determinant is a key.

4.3 SQL — the queries they set

-- SQL types: DDL (CREATE, ALTER, DROP, TRUNCATE)
--            DML (SELECT, INSERT, UPDATE, DELETE)
--            DCL (GRANT, REVOKE)   TCL (COMMIT, ROLLBACK, SAVEPOINT)

SELECT Dept, AVG(Salary) AS avg_sal
FROM   Employee
WHERE  Salary > 20000          -- WHERE filters ROWS (before grouping)
GROUP  BY Dept
HAVING AVG(Salary) > 50000     -- HAVING filters GROUPS (after grouping)
ORDER  BY avg_sal DESC;

-- 2nd highest salary (classic written question)
SELECT MAX(Salary) FROM Employee
WHERE  Salary < (SELECT MAX(Salary) FROM Employee);

-- Pattern matching: names starting with 'A'
SELECT * FROM Student WHERE Name LIKE 'A%';   -- % = any string, _ = one char

Join	Returns
INNER JOIN	only matching rows of both tables
LEFT JOIN	all left rows + matches (NULL where no match)
RIGHT JOIN	all right rows + matches
FULL OUTER JOIN	everything from both sides
CROSS JOIN	Cartesian product (m × n rows)

Traps DELETE vs TRUNCATE vs DROP: DELETE removes rows (can use WHERE, can rollback, DML); TRUNCATE removes ALL rows fast (DDL, no WHERE); DROP removes the whole table structure. · Aggregate functions ignore NULL (COUNT(*) counts all rows, COUNT(col) skips NULLs). · Primary key: NULL not allowed; UNIQUE constraint allows one NULL. · =NULL never works — use IS NULL.

4.4 Transactions — ACID

Definition — Transaction & ACID A transaction is a logical unit of work (e.g. transfer ৳500: debit A, credit B) that must be all-or-nothing. A — Atomicity: all steps happen or none (no half transfer). C — Consistency: database moves from one valid state to another (total money unchanged). I — Isolation: concurrent transactions don't see each other's half-done work. D — Durability: once committed, survives power failure (written to log/disk).

Concurrency control: locks — shared (S) lock for reading (many allowed), exclusive (X) lock for writing (only one). Two-Phase Locking (2PL) — growing phase (acquire locks) then shrinking phase (release) — guarantees serializability. Locking can cause deadlock, handled like in OS.

4.5 Indexing — B-tree vs B+ tree

Definition — Index A data structure that speeds up searching (like a book's index) at the cost of extra space and slower inserts. Databases use B+ trees.

B-tree	B+ tree (used in DBMS)
data stored in all nodes	data (records) only in leaf nodes; internal nodes hold keys only
no linked leaves	leaves linked left-to-right → fast range queries and sequential access
search may end at internal node	every search goes to a leaf → uniform time

Other quick facts: Dense index = entry for every record; sparse = entry per block. Clustered index orders the actual data (one per table). Hash index = O(1) equality search but no range queries.

Chapter 05

Computer Networks

Weight: high — OSI layers, TCP/UDP, subnetting math

5.1 OSI Model — the backbone of this chapter

Definition — OSI Model A 7-layer reference model (by ISO) that divides network communication into steps, so each layer does one job and talks to the layers above/below. Data going down gets headers added (encapsulation).

#	Layer	Job (plain words)	Data unit	Protocols	Device
7	Application	user-facing services	data	HTTP, HTTPS, FTP, SMTP (send mail), POP3/IMAP (receive mail), DNS, Telnet, SSH, DHCP	gateway
6	Presentation	format, encryption, compression	data	SSL/TLS, JPEG, ASCII	—
5	Session	open/manage/close sessions	data	NetBIOS, RPC	—
4	Transport	end-to-end delivery, error control, ports	segment	TCP, UDP	—
3	Network	logical addressing + routing	packet	IP, ICMP (ping), ARP	Router
2	Data Link	physical addressing (MAC), framing, error detection	frame	Ethernet, PPP	Switch, bridge, NIC
1	Physical	raw bits over the medium	bit	cables, RS-232	Hub, repeater, cable

Mnemonic (top→bottom) "All People Seem To Need Data Processing". TCP/IP model has 4 layers: Application, Transport, Internet, Network Access.

5.2 TCP vs UDP (guaranteed question)

TCP	UDP
connection-oriented — 3-way handshake (SYN, SYN-ACK, ACK)	connectionless — just send
reliable: acknowledgement, retransmission, ordering	unreliable, no guarantee, no order
slower, heavier header (20 bytes)	faster, light header (8 bytes)
used for: web (HTTP), email (SMTP), file transfer (FTP)	used for: video streaming, VoIP, online games, DNS, DHCP

Port numbers (memorize)

FTP 20/21 · SSH 22 · Telnet 23 · SMTP 25 · DNS 53 · DHCP 67/68 · HTTP 80 · POP3 110 · IMAP 143 · HTTPS 443.

5.3 IP addressing & subnetting — the math questions

Definition — IP address A logical address identifying a device on a network. IPv4 = 32 bits, written as 4 decimal octets (e.g. 192.168.1.1); total 2³² ≈ 4.3 billion addresses. IPv6 = 128 bits, hexadecimal with colons. The IP has a network part + host part, separated by the subnet mask.

Class	First octet	Default mask	Hosts per network	Note
A	1 – 126	255.0.0.0 (/8)	2²⁴−2 ≈ 16.7M	127.x.x.x = loopback (localhost)
B	128 – 191	255.255.0.0 (/16)	2¹⁶−2 = 65,534
C	192 – 223	255.255.255.0 (/24)	2⁸−2 = 254	private: 192.168.x.x
D	224 – 239	—	—	multicast
E	240 – 255	—	—	experimental/research

Private ranges: 10.0.0.0/8, 172.16.0.0–172.31.255.255, 192.168.0.0/16. Why −2 in host count? The all-0 host part = network address, all-1 = broadcast address — neither assignable.

Worked example 1 — hosts in a /26 /26 means 26 network bits, so host bits = 32−26 = 6. Usable hosts = 2⁶ − 2 = 62. Mask = 255.255.255.192 (because 26th bit: 192 = 11000000).

Worked example 2 — which subnet does 192.168.10.75/26 belong to? Block size = 256 − 192 = 64 → subnets start at .0, .64, .128, .192. 75 falls in the .64 subnet: network = 192.168.10.64, broadcast = 192.168.10.127, usable range = .65 – .126.

Worked example 3 — need 500 hosts, smallest subnet? 2⁹ − 2 = 510 ≥ 500 → 9 host bits → prefix = 32 − 9 = /23, mask 255.255.254.0.

Definition — CIDR vs Classful Classful addressing wastes addresses (fixed A/B/C sizes). CIDR (Classless Inter-Domain Routing) lets the prefix be any length (like /23), written as address/prefix. NAT lets many private IPs share one public IP. DHCP assigns IPs automatically; DNS translates names (google.com) → IPs.

5.4 Routing

Definition — Routing algorithms Link-state (e.g. OSPF) — every router learns the whole map and runs Dijkstra to find shortest paths. Distance-vector (e.g. RIP) — each router shares its distance table only with neighbours, using Bellman-Ford logic; suffers the count-to-infinity problem. BGP routes between ISPs (path-vector).

Error detection & media (one-liners)

Parity bit: detects single-bit errors only.

CRC (Cyclic Redundancy Check): strong error detection using polynomial division — used in Ethernet.

Hamming code: can correct single-bit errors.

Checksum: used by TCP/IP.

Fiber optic: fastest, light-based, immune to electromagnetic interference.

Twisted pair (UTP + RJ-45): common LAN cable; coaxial = cable TV.

Bandwidth measured in bps; LAN speeds in Mbps.

Topologies: star (central hub — one cable fails, only that node dies; hub fails, all die), bus (single backbone), ring (token passing), mesh (n(n−1)/2 links, most reliable).

LAN = building; MAN = city; WAN = country/world (Internet is the largest WAN).

MAC address: 48-bit physical address burned into the NIC (e.g. 00:1A:2B:3C:4D:5E) — Data Link layer. IP = logical, changeable — Network layer.

Hub broadcasts to all (dumb); switch sends only to the destination MAC (smart); router connects different networks using IP.

Modem: MOdulator-DEModulator — digital ↔ analog over phone line. Bluetooth = short-range wireless; Wi-Fi standard = IEEE 802.11; Ethernet = 802.3.

Firewall guards against unauthorized access; encryption scrambles data; the key-based system = cryptosystem.

URL parts: protocol://domain/path — https://cuet.ac.bd/admission.

Chapter 06

Digital Logic Design

Weight: high — number conversion + K-map + flip-flops

6.1 Number systems — conversions with method

Worked conversions (learn the method, not the answer) Decimal→Binary: divide by 2, read remainders bottom-up. 25 → 11001.
Binary→Decimal: weights 1,2,4,8,16… → 1101 = 8+4+0+1 = 13.
Binary→Hex: group 4 bits from right: 10111101 → 1011|1101 → BD.
Binary→Octal: group 3 bits: 10111101 → 10|111|101 → 275.
Hex digits: A=10, B=11, C=12, D=13, E=14, F=15. (2F)₁₆ = 2×16+15 = 47.
Fraction: 0.625 → multiply by 2 repeatedly: .625→1, .25→0, .5→1 → 0.101.

Definition — 1's and 2's complement 1's complement = flip every bit. 2's complement = 1's complement + 1 — this is how computers store negative numbers (only one zero, easy subtraction). Example: −5 in 8 bits: 5 = 00000101 → flip 11111010 → +1 = 11111011. Range of n-bit 2's complement: −2ⁿ⁻¹ to +2ⁿ⁻¹−1 (8-bit: −128 to +127). Subtraction A−B = A + 2's-complement(B), discard final carry.

Definition — Gray code & BCD Gray code: consecutive numbers differ in exactly one bit (used in encoders to avoid glitches). Binary→Gray: keep MSB, then XOR neighbours: 1011 → 1110. BCD: each decimal digit coded in 4 bits separately: 59 → 0101 1001. ASCII = 7-bit character code (128 symbols); Unicode covers all languages.

6.2 Logic gates

Gate	Output is 1 when…	Key fact
AND	all inputs 1	A·B
OR	any input 1	A+B
NOT	input is 0	inverter
NAND	NOT(AND) — 0 only when all 1	universal gate
NOR	NOT(OR) — 1 only when all 0	universal gate
XOR	inputs are different (odd number of 1s)	A⊕B = A'B + AB'; used in adders, parity
XNOR	inputs are same	equality detector

মনে রাখো NAND and NOR are "universal" because any circuit can be built from only NANDs (or only NORs). NOT from NAND = tie both inputs together. Basic gates = AND, OR, NOT. Logic gates are the basic building block of digital circuits.

Boolean algebra laws you'll actually use

A + A' = 1 · A · A' = 0 · A + A = A · A + 1 = 1 · A·0 = 0

De Morgan: (A·B)' = A' + B' এবং (A+B)' = A'·B'

Absorption: A + AB = A · A(A+B) = A

Distributive: A + BC = (A+B)(A+C)

Duality: swap AND↔OR and 0↔1.

SOP = Sum of Products (minterms, m); POS = Product of Sums (maxterms, M).

6.3 K-map (Karnaugh map)

Definition — K-map A grid method to simplify Boolean functions by grouping adjacent 1s in groups of 1, 2, 4, 8… (powers of 2). Rows/columns are labelled in Gray-code order (00, 01, 11, 10) so neighbours differ by one variable. A group of 2ᵏ cells eliminates k variables. "Don't care" (X) cells may be used as 1 if they enlarge a group.

Worked example F(A,B) = Σm(1,2,3): map has 1s at AB=01,10,11. Group {01,11} gives B, group {10,11} gives A → F = A + B. Same simplification algebraically: A'B + AB' + AB = A'B + A(B'+B) = A'B + A = A + B.

6.4 Combinational circuits (no memory)

Circuit	What it does	Must-know
Half adder	adds 2 bits	Sum = A⊕B, Carry = AB — 1 XOR + 1 AND
Full adder	adds 3 bits (incl. carry-in)	Sum = A⊕B⊕C, Carry = AB + C(A⊕B); = 2 half adders + 1 OR
Multiplexer (MUX)	many inputs → 1 output, chosen by select lines	2ⁿ inputs need n select lines (8:1 MUX → 3 selects); "data selector"
Demultiplexer	1 input → one of many outputs	reverse of MUX
Decoder	n inputs → 2ⁿ outputs (one active)	3×8 decoder; drives 7-segment displays
Encoder	2ⁿ inputs → n outputs	reverse of decoder
Comparator	tells A>B, A=B, A<B	equality bit uses XNOR

6.5 Sequential circuits (with memory — has clock)

Definition — Flip-flop A 1-bit memory element; the basic storage circuit of registers and RAM. Combinational output depends only on current inputs; sequential output depends on inputs + past state. A latch is level-triggered; a flip-flop is edge-triggered (changes on the clock edge).

Flip-flop	Behaviour	Note
SR	Set / Reset	S=R=1 is invalid/forbidden
JK	like SR but J=K=1 → toggle	fixes SR's invalid state; J=K=1 continuously → race-around, fixed by master–slave
D (Data/Delay)	output = D at clock edge	used in registers
T (Toggle)	T=1 → flip state	used in counters (divide-by-2)

Register: group of flip-flops storing n bits. Shift register types: SISO, SIPO, PISO, PIPO.

Counter: counts clock pulses. n flip-flops count up to 2ⁿ states; MOD-10 (decade) counter needs 4 flip-flops. Asynchronous = ripple counter (slower); synchronous = common clock.

To count 0–100 you need 7 flip-flops (2⁷=128 ≥ 101).

Propagation delay = time for output to respond to input change.

IC families: TTL (transistor-transistor logic), CMOS (lowest power). IC chips are made of silicon.

Chapter 07

Computer Architecture & 8086 Microprocessor

Weight: high — pipeline math, cache mapping, 8086 registers

7.1 The machine's skeleton

Definition — Von Neumann architecture The stored-program design (John von Neumann): program and data live in the same memory, and the CPU fetches instructions one by one. Parts: CPU (ALU + Control Unit + registers), memory, I/O, all connected by buses. Harvard architecture keeps separate memories for instructions and data (used in microcontrollers/DSP).

ALU: performs arithmetic AND comparison/logic operations (not storage).

Control Unit: the "supervisor" — directs all other units; ALU responds to commands from the control section.

Registers: fastest storage, inside CPU. PC (Program Counter): address of the next instruction. IR: the current instruction. MAR: memory address; MDR/MBR: data being transferred. Accumulator: holds ALU results. SP: stack pointer.

Instruction cycle: Fetch → Decode → Execute (→ store).

Buses (3): data bus (bidirectional), address bus (unidirectional), control bus. n address lines → can address 2ⁿ locations (16 lines → 64 KB).

Word length measured in bits. Clock speed in GHz; MIPS = Million Instructions Per Second.

RISC: few simple fixed-length instructions, more registers, pipelining-friendly (ARM). CISC: many complex variable-length instructions (Intel x86).

Firmware: software permanently stored in ROM (e.g. BIOS).

Microprocessor invented: Intel 4004 (1971), first Intel processor — 4th generation.

7.2 Memory hierarchy

Fastest/most expensive → slowest/cheapest: Registers → Cache (SRAM) → Main memory (DRAM) → SSD/Hard disk → Tape.

Memory	Facts asked
RAM	volatile, read-write. SRAM = flip-flops, fast, used for cache; DRAM = capacitor + transistor, needs refresh, used for main memory (cheaper, denser)
ROM	non-volatile. PROM write once; EPROM erase with UV light; EEPROM erase electrically; Flash = modern EEPROM (BIOS, pendrives, SSD)
Cache	small fast SRAM between CPU and RAM holding frequently used data (locality of reference). L1 (fastest, inside core) → L2 → L3
Virtual memory	hard-disk space acting as extra RAM (illusion of large memory)

Definition — Locality of reference Programs tend to re-use recently accessed data (temporal locality) and access nearby addresses (spatial locality). This is why cache works. Hit ratio = hits / total accesses; average access time = h×t_cache + (1−h)×t_memory.

Worked example Cache = 10 ns, RAM = 100 ns, hit ratio 90% → average = 0.9(10) + 0.1(100+10) = 9 + 11 = 20 ns (or 19 ns if not counting cache time on a miss — read the question's convention).

Cache mapping (3 ways)

Mapping	Rule	Trade-off
Direct	block goes to exactly ONE line: line = block mod lines	cheap, but conflicts even when cache has space
Fully associative	block can go anywhere	flexible, expensive search
Set-associative	block maps to one set, anywhere inside it (k-way)	the practical compromise

7.3 Pipelining — the exam math

Definition — Pipelining Overlapping instruction execution like an assembly line: while instruction 1 is executing, instruction 2 is being decoded and 3 fetched. A k-stage pipeline can approach k× speedup. Time for n instructions in a k-stage pipeline (cycle time t): (k + n − 1) × t, versus n·k·t without pipelining.

Worked example 5-stage pipeline, 100 instructions, 2 ns per stage: pipelined = (5+100−1)×2 = 208 ns; non-pipelined = 100×5×2 = 1000 ns; speedup ≈ 4.8×.

Definition — Hazards Things that stall the pipeline. Structural: two instructions need the same hardware. Data: an instruction needs a result not yet ready (fixed by forwarding/bypassing or stalls). Control: branch instructions — we don't know the next instruction (fixed by branch prediction).

7.4 The 8086 microprocessor

8086: 16-bit microprocessor, 20-bit address bus → addresses 2²⁰ = 1 MB memory; 16-bit data bus; ~29,000 transistors; introduced 1978.

8085: 8-bit, 16-bit address bus → 64 KB.

Physical address = Segment × 16 + Offset (i.e. segment shifted left 4 bits + offset). Example: CS=1000H, IP=0200H → PA = 10000H + 0200H = 10200H.

Segment registers (4): CS (code), DS (data), SS (stack), ES (extra) — each segment max 64 KB.

General purpose (16-bit): AX (accumulator), BX (base), CX (counter — loops), DX (data); each splits into H/L halves (AH/AL).

Pointer/index: SP, BP, SI, DI. IP = instruction pointer.

Flags: Carry, Zero, Sign, Overflow, Parity, Auxiliary + control flags (Trap, Interrupt, Direction).

BIU & EU: Bus Interface Unit fetches (has a 6-byte instruction queue → pipelining); Execution Unit executes.

Addressing modes: Immediate (MOV AX, 5), Register (MOV AX, BX), Direct (MOV AX, [1234H]), Register indirect (MOV AX, [BX]), Based/Indexed ([BX+SI+disp]).

Common instructions: MOV copy, ADD/SUB, MUL/DIV, INC/DEC, CMP compare, JMP jump, LOOP uses CX, PUSH/POP use stack, INT = software interrupt, HLT = halt, NOP = no operation, XCHG = exchange.

Interrupt vector table: first 1 KB of memory (256 interrupts × 4 bytes). NMI = non-maskable interrupt.

Chapter 08

Discrete Mathematics

Weight: medium — logic + counting + graph theory formulas

8.1 Set theory

Definition — Set A well-defined collection of distinct objects. |A| = cardinality (number of elements). Power set P(A) = set of ALL subsets; if |A| = n then |P(A)| = 2ⁿ (includes ∅ and A itself). Number of proper subsets = 2ⁿ − 1.

The formula that always appears — Inclusion–Exclusion |A∪B| = |A| + |B| − |A∩B|. Example: In a class of 60, 35 like cricket, 30 like football, 10 like both → like at least one = 35+30−10 = 55 → like neither = 5. Three sets: |A∪B∪C| = |A|+|B|+|C| − |A∩B| − |B∩C| − |A∩C| + |A∩B∩C|.

De Morgan for sets: (A∪B)' = A'∩B'. Cartesian product |A×B| = |A|·|B|.

8.2 Propositional logic

Definition — Proposition A statement that is either true or false (not both). "2+2=4" ✔, "Close the door" ✘ (command, not proposition). Connectives: ∧ AND, ∨ OR, ¬ NOT, → implies, ↔ iff.

The implication trap p → q is false ONLY when p is true and q is false. So "If the moon is made of cheese, then 1=2" is TRUE (false premise). p → q ≡ ¬p ∨ q. Converse: q→p. Inverse: ¬p→¬q. Contrapositive: ¬q→¬p — only the contrapositive is equivalent to the original.

Tautology = always true (p ∨ ¬p); contradiction = always false (p ∧ ¬p). A truth table with n variables has 2ⁿ rows. Quantifiers: ∀ for all, ∃ there exists; ¬∀x P(x) ≡ ∃x ¬P(x).

8.3 Combinatorics — the counting questions

Definition — Permutation vs Combination Permutation = arrangement, order matters: nPr = n!/(n−r)!. Combination = selection, order doesn't matter: nCr = n!/(r!(n−r)!). Hook: P = Position (order), C = Choose (group).

Worked examples (exam-identical) ① Arrange "COMPUTER" (8 distinct letters) = 8! = 40320. ② Word with repeats: "BANANA" = 6!/(3!·2!) = 60 (divide by repeats). ③ Committee of 3 from 10 people = 10C3 = 120. ④ 3-digit numbers from 1–9 without repetition = 9×8×7 = 504. ⑤ Handshakes among n people = nC2 = n(n−1)/2 → 10 people = 45. ⑥ At least one: total − none. Probability of at least one head in 3 tosses = 1 − (1/2)³ = 7/8.

Definition — Pigeonhole principle If n+1 items go into n boxes, some box has ≥ 2 items. Example: among any 13 people, two share a birth month. Generalized: ⌈n/k⌉.

Sum rule: OR → add. Product rule: AND/steps → multiply. Binomial theorem: (a+b)ⁿ has n+1 terms; coefficient of term = nCr; sum of coefficients = 2ⁿ.

8.4 Relations & functions

Relation properties: reflexive (aRa ∀a), symmetric (aRb→bRa), transitive (aRb∧bRc→aRc). All three together = equivalence relation (example: "same remainder mod 3"). Reflexive + antisymmetric + transitive = partial order (example: ≤, "divides").

Function: every input has exactly one output. Injective/one-to-one: different inputs → different outputs. Surjective/onto: every output hit. Both = bijective (invertible).

Number of functions from A(m elements) to B(n): nᵐ.

8.5 Graph theory (theory version)

Handshaking lemma: Σdegrees = 2 × |edges| → number of odd-degree vertices is always even.

Complete graph Kn: n(n−1)/2 edges; each vertex degree n−1.

Tree: connected + no cycle → exactly n−1 edges; adding any edge creates exactly one cycle.

Euler circuit (use every EDGE once, return to start): exists iff every vertex has even degree. Euler path: exactly 0 or 2 odd vertices. (Königsberg bridges — impossible, 4 odd vertices.)

Hamiltonian circuit: visit every VERTEX once — no easy condition (NP-complete).

Bipartite graph: 2-colorable ⇔ no odd cycle. Planar: Euler's formula V − E + F = 2; K5 and K3,3 are NOT planar.

Chromatic number: min colors so neighbours differ; 4-color theorem for planar maps.

Mathematical induction: prove base case P(1), then P(k)→P(k+1). Famous sums: 1+2+…+n = n(n+1)/2; 1²+2²+…+n² = n(n+1)(2n+1)/6.

Chapter 09

Software Engineering & Compiler Design

Weight: medium — SDLC models + compiler phases

9.1 SDLC

Definition — SDLC Software Development Life Cycle — the standard stages of building software: Requirement analysis → Design → Implementation (coding) → Testing → Deployment → Maintenance. Requirement gathering produces the SRS (Software Requirements Specification).

Model	Idea	When / weakness
Waterfall	strict sequence, each phase finishes before next	requirements fixed & clear; can't go back easily — inflexible
Iterative/Incremental	build in small versions, improve each round	early partial product
Spiral	iterative + explicit risk analysis each loop	large, risky projects
Prototype	quick throwaway model to confirm requirements	unclear requirements
Agile (Scrum)	short sprints (1–4 weeks), working software over documentation, welcome change; roles: product owner, scrum master; daily stand-up	needs customer involvement
V-model	each dev phase paired with a test phase	verification-heavy

9.2 Testing

Definition — Verification vs Validation Verification: "are we building the product right?" (reviews, matches design). Validation: "are we building the right product?" (testing against user needs).

Black-box testing: test inputs/outputs without seeing code (boundary value analysis, equivalence partitioning).

White-box: test internal logic/paths (statement, branch coverage).

Levels: Unit (one module) → Integration (modules together) → System (whole product) → Acceptance/UAT (by customer). Alpha testing = in-house; beta = by real users outside.

Regression testing: re-test after changes to ensure nothing broke.

Bug/defect: error in software; debugging = finding & fixing.

Cohesion = how focused one module is (want HIGH); coupling = dependence between modules (want LOW).

UML: Unified Modeling Language — use-case, class, sequence diagrams.

COCOMO: cost estimation model. Software crisis = projects late/over-budget.

9.3 Compiler design — the 6 phases

Definition — Compiler Translates the whole high-level program into machine code before running. Phases, in order (analysis then synthesis): Lexical analysis → Syntax analysis → Semantic analysis → Intermediate code generation → Code optimization → Code generation, with a symbol table + error handler used by all phases.

Phase	Does	Output / example
Lexical analysis (scanner)	groups characters into tokens; removes whitespace/comments	`int a = 5;` → keyword, identifier, operator, constant. Uses regular expressions / finite automata
Syntax analysis (parser)	checks grammar, builds parse tree	catches `a = 5 +;`. Top-down: LL(1), recursive descent. Bottom-up: LR, SLR, LALR (used by YACC)
Semantic analysis	meaning checks: type checking, undeclared variables	catches int + string
Intermediate code	machine-independent form	three-address code: t1 = b * c
Optimization	make code faster/smaller	constant folding: 2*3 → 6; dead-code removal
Code generation	target assembly/machine code	MOV, ADD…

Assembler: assembly → machine code. Linker: joins object files/libraries into one executable. Loader: puts the executable into memory to run.

Interpreter: executes line by line (Python, older BASIC); slower, but errors shown immediately per line. Java = hybrid (compile to bytecode + JVM interprets/JIT).

Lex = lexical analyzer generator; YACC = Yet Another Compiler Compiler (parser generator).

Ambiguous grammar: a string with 2+ parse trees. Left recursion must be removed for top-down parsing.

Chapter 10

Quantitative Aptitude

The ~20% math section — every mark here is easy if formulas are automatic

10.1 Percentage

Core moves x% of N = N×x/100. · Increase of x% → multiply by (1 + x/100). · Successive change: a% then b% → net = a + b + ab/100. Example: +20% then −20% → 20−20−4 = −4% (never zero!). · If price rises x%, consumption must fall x/(100+x)×100% to keep spending same: rise 25% → cut 20%. · A is x% more than B ⇒ B is x/(100+x)×100% less than A.

10.2 Profit & Loss

Core moves Profit% = (SP−CP)/CP × 100 (always on cost price unless stated). · SP = CP × (100±p)/100. · Classic: sold two items at same price, one +x% one −x% → overall loss of x²/100 %. · Discount is on marked price: SP = MP(100−d)/100. · Two successive discounts a%, b% = a + b − ab/100 (same successive formula). · Dishonest seller using 900 g for 1 kg: gain = 100/900 × 100 = 11.11%.

10.3 Ratio, Average, Mixture

Core moves a:b = 3:4 with total 140 → parts = 140/7 → 60 and 80. · If a:b = 2:3 and b:c = 4:5 → a:b:c = 8:12:15 (make b equal). · Average = sum/count; if average of n numbers is A and one number x leaves, new average = (nA − x)/(n−1). · Average of first n natural numbers = (n+1)/2. · Alligation: mixing prices c₁ < m < c₂ → ratio = (c₂−m):(m−c₁). Example: mix ৳20 and ৳30 rice for ৳26 → ratio 4:6 = 2:3.

10.4 Interest

Core moves Simple interest SI = PRT/100 — grows linearly. · Compound: A = P(1 + r/100)ᵗ. · Difference CI − SI for 2 years = P(r/100)². Example: P=10000, r=10% → diff = 100. · Money doubles at SI in 100/r years; roughly at CI in 72/r years (rule of 72).

10.5 Speed–Time, Work, Ages

Core moves Speed = distance/time; km/h → m/s multiply by 5/18. · Train crossing a pole: covers its own length; crossing a platform: length of train + platform. · Two trains opposite directions: speeds ADD; same direction: SUBTRACT. · Average speed for equal distances = 2xy/(x+y) (NOT (x+y)/2). · Work: A does job in a days → rate 1/a per day. A=10 days, B=15 days together: 1/10+1/15 = 1/6 → 6 days. · Pipes: inlet positive, leak negative. · Ages: translate into equations. "Father is 3× son; in 12 yrs 2×": 3x+12 = 2(x+12) → x=12, father 36.

10.6 Number system quickies

Sum 1..n = n(n+1)/2 (1..100 = 5050). Sum of first n odd = n². Sum of first n even = n(n+1).

Divisibility: by 3/9 → digit sum; by 4 → last 2 digits; by 8 → last 3; by 11 → alternating digit sums differ by multiple of 11.

LCM × HCF = product of the two numbers.

Prime: exactly two factors; 2 = only even prime; 1 is NOT prime. Primes under 20: 2,3,5,7,11,13,17,19 (eight of them).

Unit digit cycles: powers of 2 → 2,4,8,6 repeat; of 3 → 3,9,7,1; of 7 → 7,9,3,1. 7^15: 15 mod 4 = 3 → unit digit 3.

Number of factors: N = p^a·q^b → (a+1)(b+1). 72 = 2³·3² → 12 factors.

Logs: log(ab)=log a+log b; log(aⁿ)=n log a; log₂8 = 3; log 1 = 0.

Quadratic ax²+bx+c: sum of roots −b/a, product c/a; discriminant b²−4ac (0 → equal roots).

Probability: favourable/total. Two dice sum 7 → 6/36 = 1/6. Cards: 52 cards, 4 suits, 13 each; P(ace) = 4/52 = 1/13.

Chapter 11

Analytical Reasoning

Puzzle marks — technique matters more than knowledge

11.1 Series (number & letter)

Method: find the gap pattern 2, 6, 12, 20, 30, ? → gaps 4,6,8,10 → next gap 12 → 42 (also = n²+n). 1, 1, 2, 3, 5, 8, ? → Fibonacci → 13. 3, 9, 27, 81 → ×3 → 243. Mixed: 2, 3, 5, 9, 17 → gaps double → 33. Letters = positions (A=1…Z=26): B, D, H, P? → 2,4,8,16 → doubling. Reverse alphabet trick: Z=1 side, A↔Z, B↔Y (sum to 27).

11.2 Blood relations & directions

Method Draw a mini family tree; mark ♂/♀. "Pointing to a photo, Rahim says: he is the son of my father's only son" → my father's only son = Rahim himself → photo = Rahim's son. Directions: draw N↑ E→ axes and walk it. Man goes 3 km north, 4 km east → displacement = √(3²+4²) = 5 km (Pythagoras, exam favourite). Sunrise side = East; at sunrise your shadow points West.

11.3 Seating, ranking, clocks, calendar

Circular seating facing center: left = clockwise. Draw the circle; place the most-constrained person first.

Ranking: position from other end = (total + 1 − position). 15th from top in 40 → 26th from bottom. Total people = rank from top + rank from bottom − 1.

Clock angle = |30H − 5.5M|. At 3:30 → |90 − 165| = 75°. Hands overlap 11 times in 12 hours.

Calendar: ordinary year = 52 weeks + 1 odd day → next year same date shifts +1 weekday (+2 after 29 Feb). Leap year: divisible by 4; centuries must be divisible by 400 (2000 ✔, 1900 ✘).

Syllogism: draw Venn diagrams; "All A are B" = A inside B; "Some" = overlap; check whether the conclusion is FORCED in every possible diagram, not just one.

Coding: CAT→DBU means +1 shift; find the shift, apply it.

Chapter 12

English Essentials

Short section — synonyms, prepositions, correction

12.1 High-frequency word pairs (from past M.Sc. banks)

Fair = just, impartial, unbiased. Ameliorate = improve. Abundant = plentiful (ant: scarce).

Candid = frank, honest. Obsolete = outdated. Feasible = possible/practical.

Diligent = hardworking. Prudent = wise/careful. Vague = unclear.

Augment = increase. Terminate = end. Contagion = spread of disease by contact.

Goliath = a giant. Colossal/enormous/immense = huge. Trivial = unimportant.

Benevolent = kind (ant: malevolent). Transparent = clear. Ambiguous = double meaning.

12.2 Grammar spots they test

Subject–verb: "Each/Every/Either… " takes singular verb. "The number of students is…", "A number of students are…".

Prepositions: good at, afraid of, congratulate on, die of disease, consist of, depend on, interested in, capable of, angry with (person) / at (thing).

Since + point of time (since 2019); for + duration (for 5 years).

Fewer for countable, less for uncountable.

Conditionals: If + past → would (If I were rich, I would…). "I wish I were".

Voice: "He writes a letter" → "A letter is written by him" (obj→subj, verb→be+V3).

Idioms: a piece of cake = very easy; once in a blue moon = rarely; break the ice = start conversation; ins and outs = details.

Chapter 13

Written Part: Compare & Define

These exact comparisons appear in the written section of M.Sc. papers — write 3–4 points each

Compiler vs Interpreter

Compiler translates the whole program at once into machine code; runs fast afterward; shows all errors together (C, C++). Interpreter translates and executes line by line; slower; stops at the first error (Python). Java uses both (bytecode + JVM).

Array vs Linked List

Array: contiguous memory, fixed size, O(1) index access, costly insert/delete (shift). Linked list: scattered nodes with pointers, dynamic size, O(1) insert/delete at a known node, O(n) access, extra memory for pointers.

Stack vs Queue

Stack = LIFO, one end (push/pop), used in recursion/undo/DFS. Queue = FIFO, insert rear delete front, used in scheduling/BFS/printing.

MAC address vs IP address

MAC: 48-bit physical address, fixed in NIC by manufacturer, Data-link layer, local delivery. IP: 32-bit (IPv4) logical address, assigned by network/DHCP, Network layer, end-to-end routing, changes with network.

HTTP vs HTTPS

HTTPS = HTTP + SSL/TLS encryption; port 443 vs HTTP port 80; protects passwords/payments from eavesdropping; shows padlock; needed for any login/payment page.

TCP vs UDP

TCP: connection-oriented (3-way handshake), reliable, ordered, slower — web/email/file transfer. UDP: connectionless, no guarantee, faster — streaming/VoIP/games/DNS.

High-level vs Low-level language

High-level: human-readable, portable, needs compiler/interpreter (C, Java, Python). Low-level: machine/assembly, hardware-specific, fast, hard to write; assembly needs an assembler.

RAM vs ROM

RAM: volatile, read/write, holds running programs, fast, larger. ROM: non-volatile, read-only (mostly), holds firmware/BIOS/bootstrap loader.

Primary key vs Foreign key

Primary: uniquely identifies rows in its own table, no NULL/duplicate, one per table. Foreign: references a primary key of another table to link them; may repeat, may be NULL; enforces referential integrity.

DELETE vs TRUNCATE

DELETE: DML, row-by-row, supports WHERE, can rollback, fires triggers. TRUNCATE: DDL, removes all rows instantly, no WHERE, resets identity, faster.

Process vs Thread

Process: independent, own memory space, heavy context switch. Thread: lightweight unit inside a process, shares code/data/files with sibling threads, own stack/registers, cheap switching.

Paging vs Segmentation

Paging: fixed-size blocks, invisible to programmer, internal fragmentation. Segmentation: variable-size logical units (code/data/stack), visible, external fragmentation.

Multiprogramming vs Multitasking vs Multiprocessing

Multiprogramming: several programs in memory, CPU switches when one waits. Multitasking: time-sliced rapid switching (user feels parallel). Multiprocessing: literally 2+ CPUs working simultaneously.

Constructor (define + properties)

A special member function with the same name as the class, no return type, called automatically at object creation, used to initialize data members; can be overloaded (default, parameterized, copy constructor).

Overloading vs Overriding

Overloading: same function name, different parameters, same class — compile-time polymorphism. Overriding: same name AND same signature, redefined in derived class (virtual) — run-time polymorphism.

Structure vs Class (C++)

Only real difference: struct members are public by default, class members private by default. Both can have functions in C++.

SRAM vs DRAM

SRAM: flip-flop based, no refresh, faster, expensive → cache. DRAM: capacitor based, needs periodic refresh, denser, cheaper → main memory.

LAN vs WAN

LAN: small area (building), high speed, privately owned, Ethernet/Wi-Fi. WAN: cities/countries, slower per link, leased/public infrastructure; Internet = biggest WAN.

B-tree vs B+ tree

B-tree stores records in all nodes; B+ tree keeps records only in linked leaf nodes → faster range queries and uniform search depth; databases use B+ trees for indexing.

Virus vs Worm vs Trojan

Virus: attaches to a host file, needs user action to spread. Worm: self-replicating, spreads over network by itself, eats memory/bandwidth. Trojan horse: pretends to be useful software while doing harm; does not self-replicate. All are malware.

Parameter vs Argument

Parameter: the variable in the function definition (void f(int x)). Argument: the actual value passed in the call (f(5)). Call by value copies; call by reference/pointer lets the function change the original.

Chapter 14

Rapid-Fire Fact Bank + Full Forms

Read this whole chapter every day — direct one-line MCQ answers from the question banks

14.1 Computer fundamentals one-liners

Father of computer: Charles Babbage (Analytical Engine). Basic architecture: John Von Neumann.

First electronic general-purpose computer: ENIAC (Eckert & Mauchly, vacuum tubes).

Generations (5): 1 vacuum tube → 2 transistor → 3 IC → 4 microprocessor/VLSI → 5 AI.

Supercomputer inventor: Seymour Cray. India's first: PARAM. Banks/railways/airlines use mainframes.

Most powerful computer type: supercomputer — for math-intensive scientific work.

First computer mouse: Douglas Engelbart. Mouse named for its tail-like cable.

First web browser: WorldWideWeb; WWW invented by Tim Berners-Lee; web standard body = W3C.

First email: 1971, Ray Tomlinson. First web-mail: Hotmail (Sabeer Bhatia, 1996). Spam = unsolicited email. BCC = Blind Carbon Copy.

Big Blue = IBM. Intel HQ = Santa Clara, California. First Intel processor = 4004. Intel & AMD make processors; Microsoft does NOT.

Bit = smallest unit; byte = 8 bits; nibble = 4 bits. KB=1024 B, MB=1024 KB, GB=1024 MB, TB=1024 GB. Data order: bit → byte → field → record → file → database.

1 GB ≈ one billion bytes; hard-drive capacity in GB; LAN speed in Mbps; resolution of laser printer in DPI.

Memory device circuit: flip-flop. Word length in bits. Cache = high-speed memory for frequently used data.

Non-volatile: ROM/PROM/EPROM/EEPROM/flash; volatile: RAM. PROM = write once. Most advanced ROM = EEPROM. BIOS stored in flash/ROM; its settings in CMOS.

Booting = loading OS to RAM; bootstrap loader in ROM starts it; POST checks hardware (video, memory) — ScanDisk does NOT run in POST.

Working document lives in RAM; saved documents on disk (secondary storage). Semiconductor memory is NOT secondary storage.

Icons = graphical object pictures; GUI = Graphical User Interface; system tray shows clock/volume; title bar shows window name; taskbar switches programs.

Recycle bin stores deleted files; one per partition (3 drives → 3 bins); emptying frees space (sending to bin does NOT).

OS is system software; MS Word/Excel/Photoshop = application software; Redhat Linux distribution counted as OS (not application package). Oracle, Pascal, Notepad are NOT operating systems.

Linux: open source — anyone can modify code (that's the key difference from Windows). UNIX (AT&T Bell Labs) is multi-user + multitasking + time-sharing. Mac OS is UNIX-based. OS/2 = IBM.

Kernel = core of OS; memory-resident part. Shell = interface layer. Windows Explorer = file manager.

Real-time OS example: process control / fuel injection. PDA OS = single-user single-task.

Modem converts digital↔analog for phone lines; not used inside a LAN. Router decodes radio-signal data at home.

Firewall: blocks unauthorized access. Hacking = unauthorized entry; identity theft = posing as someone; spoofing = stealing passwords; biometrics = fingerprint/retina security; DoS attack = fake traffic flood.

Melissa (1999) = email virus. Worm dies when memory/disk runs out. Plain-text email cannot carry a virus. Most computer crime is committed by insiders.

Blog = web log (personal journal). Cookie = small text stored by browser. Homepage = first page of a website. URL = address of a page.

Valid email format: name@site.domain (one @). Subject line describes the message.

Input devices: keyboard, mouse, scanner, OMR, MICR (bank cheques), barcode reader (laser scanner), light pen, joystick, touch screen. Output: monitor (VDU), printer (hardcopy), plotter, speaker.

OMR reads pencil marks; OCR reads printed characters; MICR reads magnetic ink on cheques.

Impact printer: dot-matrix (ribbon + print head); daisy wheel = printer type. Laser printer uses drum + laser (no print head). Inkjet needs a cartridge.

Pixel = smallest dot on screen. Monitor types: CRT and LCD. Public info displays = touch-screen kiosks.

Keyboard: QWERTY; function keys = 12; Space key has no name printed; Windows key opens Start.

Floppy 3.5", CD-ROM 680–700 MB; capacity order: DVD > CD > floppy. CD-ROM cannot be modified. Backup file extension .bak. Seagate/WD/Samsung make hard disks; Intel does not.

Zipping = compressing. WinZip compresses. Defragmenter speeds up disk; ScanDisk repairs FAT/lost clusters.

Shortcuts: Ctrl+C copy, Ctrl+X cut, Ctrl+V paste, Ctrl+Z undo, Ctrl+Y redo, Ctrl+P print, Ctrl+S save, Ctrl+A select all, Ctrl+F find, Ctrl+H replace, F7 spell-check, F5 slideshow (PowerPoint) / refresh (Windows), F2 rename, Alt+Tab switch windows, Ctrl+Alt+Del task manager, Shift+Delete permanent delete, Ctrl+End = end of document, Ctrl+Home = beginning.

Excel: formula begins with =; A1 = first cell; $A$1 = absolute reference; data in rows & columns; fill handle = small black square; SUM via AutoSum; NOW() = date+time, TODAY() = date; %MOD() gives remainder; charts: pie = proportions, line = trend over time; workbook = collection of worksheets; VisiCalc = first spreadsheet; Lotus 1-2-3 = old DOS spreadsheet.

Word: .docx (2007+), word wrap moves text to next line automatically, mail merge = same letter to many people (needs main document + data source + merge fields), thesaurus = synonyms, gutter margin = binding side, portrait = default orientation, header/footer prints on every page, Ctrl+Enter = page break, Winword.exe starts Word.

PowerPoint: .pptx; slide master = same logo on all slides; slide transition = effect between slides; animation scheme = motion on objects; slide sorter view = see all slides; F5 = start show; Esc = stop; placeholder = box holding text; handout = printed audience copy.

14.2 Full forms (direct questions)

CPU — Central Processing Unit · ALU — Arithmetic Logic Unit · CU — Control Unit

RAM/ROM — Random Access / Read Only Memory · PROM — Programmable ROM · EEPROM — Electrically Erasable PROM

BIOS — Basic Input Output System · POST — Power-On Self Test · CMOS — Complementary Metal-Oxide Semiconductor

USB — Universal Serial Bus · PCI — Peripheral Component Interconnect · SATA — Serial ATA · IDE — Integrated Drive Electronics

HTTP(S) — HyperText Transfer Protocol (Secure) · HTML — HyperText Markup Language · URL — Uniform Resource Locator

WWW — World Wide Web · ISP — Internet Service Provider · IP — Internet Protocol · TCP — Transmission Control Protocol · UDP — User Datagram Protocol

FTP — File Transfer Protocol · SMTP — Simple Mail Transfer Protocol · POP3 — Post Office Protocol 3 · IMAP — Internet Message Access Protocol

DNS — Domain Name System · DHCP — Dynamic Host Configuration Protocol · NAT — Network Address Translation · VPN — Virtual Private Network

LAN/MAN/WAN — Local/Metropolitan/Wide Area Network · Wi-Fi — Wireless Fidelity · NIC — Network Interface Card · MAC — Media Access Control

SQL — Structured Query Language · DBMS — Database Management System · ACID — Atomicity Consistency Isolation Durability · ER — Entity Relationship

DDL/DML/DCL — Data Definition / Manipulation / Control Language

OS — Operating System · GUI — Graphical User Interface · CLI — Command Line Interface · FAT — File Allocation Table · NTFS — New Technology File System · FIFO/LIFO — First/Last In First Out

AI — Artificial Intelligence · ML — Machine Learning · IoT — Internet of Things · VR/AR — Virtual/Augmented Reality

ASCII — American Standard Code for Information Interchange · BCD — Binary Coded Decimal · MIPS — Million Instructions Per Second

PDF — Portable Document Format · JPEG — Joint Photographic Experts Group · GIF — Graphics Interchange Format · MP3 — MPEG Audio Layer 3 · AVI — Audio Video Interleave (Microsoft) · WAV — sound file

UPS — Uninterruptible Power Supply (backup power) · VDU — Visual Display Unit · CRT/LCD/LED — Cathode Ray Tube / Liquid Crystal / Light Emitting Diode

DPI — Dots Per Inch · bps — bits per second · GHz — GigaHertz

OOP — Object Oriented Programming · IDE — Integrated Development Environment · API — Application Programming Interface · SDK — Software Development Kit

SDLC — Software Development Life Cycle · SRS — Software Requirements Specification · UML — Unified Modeling Language · UAT — User Acceptance Testing

CIDR — Classless Inter-Domain Routing · OSPF — Open Shortest Path First · RIP — Routing Information Protocol · ICMP — Internet Control Message Protocol · ARP — Address Resolution Protocol

JVM — Java Virtual Machine · JDK — Java Development Kit · CSS — Cascading Style Sheets · PHP — Hypertext Preprocessor · XML — eXtensible Markup Language

VIRUS — Vital Information Resource Under Siege (quiz form) · VLSI — Very Large Scale Integration · IC — Integrated Circuit · TTL — Transistor-Transistor Logic

Chapter 15

15-Day Plan & Exam-Day Strategy

Plan (5 July → 20 July)

Days	Do
Day 1–2	Ch 1 (C/OOP) + Ch 2 (DSA). Hand-trace every code example; rewrite the complexity table from memory.
Day 3–4	Ch 3 (OS) + Ch 4 (DBMS). Solve the scheduling and page-fault examples on paper yourself; write the normalization chain from memory.
Day 5–6	Ch 5 (Networks) + Ch 6 (DLD). Do 5 fresh subnetting problems and 3 K-map simplifications you invent yourself.
Day 7–8	Ch 7 (Architecture/8086) + Ch 8 (Discrete). Pipeline formula + physical-address calculation until automatic.
Day 9	Ch 9 (SE + Compiler) + Ch 13 (written comparisons) — practice writing 5 comparisons in 3–4 points each, by hand.
Day 10–11	Ch 10–12 (Quant, Analytical, English). Time yourself: 60 seconds max per math problem.
Day 12–13	Full revision pass of all chapters — only the highlighted terms, tables, and boxes.
Day 14	Solve your uploaded question banks (Father of Admission Test MCQs + Examveda) as a mock exam. Mark misses; re-read only those sections here.
Day 15–19	Daily: Ch 14 rapid-fire + full forms (20 min), one subject deep-revise per day, one timed mock.
19 July night	Only Ch 14 + your personal mistake list. Sleep early. No new topics.

In the exam hall

Three passes: Pass 1 — answer only instant-sure questions. Pass 2 — the calculation ones (scheduling, subnetting, quant). Pass 3 — eliminate-and-guess the rest. Never let one hard question eat 5 minutes.
Negative marking check: confirm from the question paper whether wrong answers deduct marks; if yes, guess only when you can eliminate 2 options.
Output questions: trace on the margin with a table of variable values — never in your head.
"All of the above" / "None of these": if you can verify two options are true, "All of the above" is usually the answer.
Units trap: KB vs Kb, ms vs ns, bits vs bytes — read twice.
For the written part: answer in points, not paragraphs — 3–4 crisp differences with one example earns full marks fast.

Honest note: no single document can guarantee 100% — exams always throw one or two surprises — but this book covers the full syllabus that CUET/BUET/KUET/JU M.Sc. papers have actually drawn from, and if the highlighted facts, tables, and worked methods here are automatic for you, you are prepared for the overwhelming majority of what will appear. Combine it with the two question-bank PDFs you already have (use them as mocks, this book as the theory), and you're set.