Previous Year Question Papers Portal
Access 4 years of university exam question papers across all 8 Semesters (1st to 8th) for CSE, AIML, DS & Engineering branches. Practice authentic RGPV examination pattern questions with structured solutions, key formulas, and 4-year branch roadmaps.
Subjects for Semester 1 Found 0 subjects
Engineering Chemistry
Water analysis and treatment, polymer science, lubricants, coal analysis, spectroscopy, and phase rule.
- EDTA method calculation for water hardness is highly important. Learn the formula.
- Differentiate between thermoplastic and thermosetting polymers. Standard question.
- Calorific value of coal using Bomb Calorimeter (with diagram) is a frequent examiner choice.
- Understand the application of UV-Visible and IR spectroscopy in identifying functional groups.
- Hardness in terms of CaCO3 equivalent = [Mass of hardness producing salt * 100] / [2 * Chemical equivalent of salt]
- Calorific Value (HCV) = [(W + w)(t2 - t1) - corrections] / Mass of fuel
- Gibbs Phase Rule: F = C - P + 2
Engineering Mathematics-I
Foundational calculus, expansion of functions, partial differentiation, multiple integrals, and vector calculus.
- Practice Curve Tracing rules thoroughly. One 7-mark question is almost guaranteed.
- Remember the formula for Leibnitz's Theorem for finding the nth derivative.
- Beta and Gamma function relations are extremely useful for solving complex integrals quickly.
- For Vector Calculus, practice Gauss Divergence Theorem and Green's Theorem proofs.
- Leibnitz Theorem: (uv)_n = u_n v + n C_1 u_{n-1} v_1 + n C_2 u_{n-2} v_2 + ... + u v_n
- Euler's Theorem for Homogeneous Functions: x(∂z/∂x) + y(∂z/∂y) = nz
- Relation between Beta and Gamma: B(m, n) = [Γ(m) * Γ(n)] / Γ(m + n)
- Radius of Curvature (Cartesian): ρ = [1 + (y_1)^2]^(3/2) / y_2
English for Communication
Fundamentals of technical and professional communication, language proficiency, grammar, phonetics, formal correspondence, report writing, and presentation skills.
- Understand the communication cycle (Sender, Encoding, Channel, Receiver, Decoding, Feedback) and barriers thoroughly.
- Practice standard formats for formal business letters, resumes with cover letters, and technical reports.
- Memorize the 7 Cs of effective communication: Clarity, Conciseness, Concreteness, Correctness, Coherence, Completeness, and Courtesy.
- Review rules of active-passive voice transformations and common grammatical pitfalls.
- Communication Cycle: Sender -> Encoding -> Medium/Channel -> Decoding -> Receiver -> Feedback
- 7 Cs of Communication: Clear, Concise, Concrete, Correct, Coherent, Complete, Courteous
- Barriers to Communication: Semantic, Psychological, Environmental/Physical, Organizational
- Kinesics: Study of body language, facial expressions, eye contact, and gestures in oral communication
Basic Electrical & Electronics Engineering
DC circuit analysis, network theorems, single-phase and three-phase AC circuits, magnetic circuits, single-phase transformers, rotating electrical machines, and semiconductor diode/transistor fundamentals.
- Master DC network theorems: Thevenin, Norton, Superposition, and Maximum Power Transfer. Draw equivalent circuits with values.
- In AC circuits, practice phasor diagrams and calculate active, reactive, and apparent power, and power factor cos(φ).
- For single-phase transformers, learn the equivalent circuit, phasor diagrams for lagging/leading power factors, and efficiency formulas.
- Draw neat VI characteristics for PN junction diode, Zener diode, and BJT in Common Emitter (CE) configuration.
- Thevenin Theorem: V_th = open-circuit voltage, R_th = deactivated network resistance. I_L = V_th / (R_th + R_L)
- Maximum Power Transfer Theorem: P_max = (V_th)^2 / (4 * R_th) when R_L = R_th
- AC Power Triangle: P = V I cos φ (Watts), Q = V I sin φ (VAR), S = V I (VA), cos φ = R / Z
- Transformer EMF: E1 = 4.44 f N1 Φ_m, E2 = 4.44 f N2 Φ_m. Voltage Ratio: E1/E2 = N1/N2 = I2/I1
- 3-Phase Star: V_L = √3 V_ph, I_L = I_ph. 3-Phase Delta: V_L = V_ph, I_L = √3 I_ph. Total Power P = √3 V_L I_L cos φ
- BJT CE Current Gain: β = I_c / I_b, α = β / (1 + β), I_e = I_b + I_c
Basic Computer Engineering
Introduction to computers, algorithms, C++ programming basics, OOPs concepts, DBMS, networking, and cyber security.
- For C++ questions, always write code snippets. Full marks are awarded for working code structures.
- Memorize the OSI model layers and their functions. A 7-mark question is extremely common.
- Understand standard SQL queries (SELECT, UPDATE, DELETE, JOINs). They are highly scoring.
- Know the difference between compiler and interpreter, and different operating systems functions.
- OSI Model Layers (Top to Bottom): Application -> Presentation -> Session -> Transport -> Network -> Data Link -> Physical
- OOP Pillars: Encapsulation, Abstraction, Inheritance, Polymorphism
- DBMS Integrity Rules: Entity Integrity (Primary Key != Null), Referential Integrity (Foreign Key)
Engineering Physics
Wave optics (interference, diffraction, polarization), lasers, fiber optics, quantum mechanics, and superconductors.
- Practice Newton's Rings experiment setup and formula derivation. Highly frequent.
- Understand the difference between Step-index and Graded-index optical fibers.
- Learn the derivation of Schrodinger Time-Independent wave equation. Must study.
- Memorize Einstein's A & B coefficients derivation for Lasers.
- Newton's Rings Diameter (Bright): D_n^2 = 2(2n - 1)λR
- Numerical Aperture (NA) = sin θ_max = √(n_1^2 - n_2^2)
- Schrodinger Equation (Time Independent): ∇^2ψ + (8π^2m/h^2)(E - V)ψ = 0
- de-Broglie wavelength: λ = h / p = h / √(2mE)
Engineering Mathematics-II
First and second-order ordinary differential equations, series solutions, Laplace transforms, and Fourier series.
- For Second Order Linear Differential Equations, master finding Complementary Function (CF) and Particular Integral (PI).
- Laplace transform of standard functions and Inverse Laplace using Partial Fractions is a sure question.
- Remember the Dirichlet's conditions for expanding a function in a Fourier Series.
- Practice solving differential equations using power series (Frobenius Method). One 7-mark question is guaranteed.
- Complementary Function (Real & Equal Roots m1=m2): CF = (C1 + C2*x)e^(m1*x)
- Laplace Transform of t^n: L{t^n} = n! / s^(n+1) (for integer n)
- First Shifting Theorem: L{e^(at) f(t)} = F(s - a)
- Fourier Series expansion: f(x) = a0/2 + Σ[an cos(nx) + bn sin(nx)]
Basic Mechanical Engineering
Engineering materials, vernier caliper measurements, properties of steam, steam boilers, IC engines, and thermodynamics.
- Differentiate clearly between 2-Stroke and 4-Stroke IC engines. Always draw indicator diagrams.
- Understand the working, construction, and mounting vs accessory lists for Babcock & Wilcox and Cochran boilers.
- Learn standard definitions of dryness fraction, latent heat, and superheated steam.
- Derive the air standard efficiency of the Otto Cycle.
- Otto Cycle Efficiency: η = 1 - (1 / r^(γ-1)) where r is compression ratio
- Dryness Fraction: x = mass of dry steam / (mass of dry steam + water mass)
- Enthalpy of Wet Steam: h = h_f + x * h_fg
- Characteristic Gas Equation: PV = mRT
Basic Civil Engg. & Mechanics
Civil materials, surveying principles, concrete technology, applied mechanics force systems, and centroid calculations.
- Verify Lami's Theorem using force resolution. Always draw free-body diagrams (FBDs).
- For Surveying, master numericals on calculating local attraction and correcting compass bearings.
- Understand the difference between chain surveying and compass surveying.
- Practice centroid derivations for standard shapes like triangles and semicircles.
- Lami's Theorem: P / sin α = Q / sin β = R / sin γ
- Reduced Bearing to Whole Circle Bearing relationships
- Moment of Inertia (Rectangle): I_xx = b*h^3 / 12, I_yy = h*b^3 / 12
- Parallel Axis Theorem: I_p = I_g + A * d^2
Engineering Graphics
Drawing instruments, plain and diagonal scales, conics, projections of points, lines, planes, and solids, and isometric views.
- A diagonal scale numerical is mandatory. Practice constructing scale calculations first.
- Memorize the projection layouts of a line inclined to both HP and VP (Master Line Problem).
- Understand the difference between First Angle and Third Angle projections.
- Be prepared to draw isometric projections of simple solid shapes like cylinders and prisms.
- Representative Fraction (R.F.) = Length of drawing / Actual length of object
- Length of Scale (L.O.S.) = R.F. * Maximum distance to be measured
- Apparent Angle in Line Projection relationships
Discrete Mathematics
Mathematical logic, propositions, predicates, set theory, relations, Hasse diagrams, lattice theory, algebraic structures (groups, rings, fields), recurrence relations, generating functions, and graph theory.
- Master mathematical induction proof template: Base case, Induction hypothesis P(k), and Inductive step P(k+1).
- Construct detailed truth tables to prove logical equivalences, tautologies, and valid arguments.
- For recurrence relations, write the characteristic equation, find roots, and solve for constants using initial conditions.
- Remember Euler's graph formula (V - E + R = 2) and Handshaking theorem (Σ deg(v) = 2|E|).
- Principle of Inclusion-Exclusion: |A ∪ B ∪ C| = |A| + |B| + |C| - (|A ∩ B| + |B ∩ C| + |A ∩ C|) + |A ∩ B ∩ C|
- Euler's Planar Graph Formula: V - E + R = 2 (for connected planar graphs)
- Handshaking Lemma: Σ deg(v) = 2 * |E|. Hence, number of odd degree vertices is always even
- Linear Homogeneous Recurrence: a_n - c1*a_{n-1} - c2*a_{n-2} = 0 -> Characteristic: r^2 - c1*r - c2 = 0
- Lagrange's Theorem (Groups): For finite group G and subgroup H, |H| divides |G|
Data Structures
Linear and non-linear data structures including stacks, queues, linked lists, trees (BST, AVL, B-trees), graphs (traversals, shortest paths, spanning trees), sorting, searching, and hashing techniques.
- Always write clean C/C++ pseudo-code or functions with proper time and space complexity annotations.
- Practice step-by-step tree traversals (Inorder, Preorder, Postorder) and construct trees from Given Inorder & Preorder/Postorder sequences.
- For AVL Tree insertions, draw all rotation steps (LL, RR, LR, RL) with balance factors clearly marked.
- Trace Dijkstra's, Kruskal's, and Prim's algorithms using neat tabular vertex-distance records.
- Binary Tree: Max nodes at level L = 2^L. Max nodes in tree of height h = 2^(h+1) - 1
- AVL Balance Factor: BF(node) = Height(LeftSubtree) - Height(RightSubtree) ∈ {-1, 0, 1}
- Binary Heap: Parent(i) = ⌊(i-1)/2⌋, LeftChild(i) = 2i + 1, RightChild(i) = 2i + 2
- Time Complexities: QuickSort Avg O(N log N) / Worst O(N^2); MergeSort O(N log N); Binary Search O(log N); Hash Table O(1) avg
Digital Systems
Boolean algebra, logic gates, combinational circuit design (adders, multiplexers, decoders), sequential circuits (latches, flip-flops, counters, shift registers), finite state machines, semiconductor memories, and logic families.
- In K-Maps, always draw optimal looping groups (octets, quads, pairs) and write down the simplified SOP/POS expression.
- Draw complete circuit diagrams with pinouts for Flip-Flops (SR, JK, D, T) with truth and excitation tables.
- For Synchronous Counter design: Draw state diagram -> State table -> Excitation table -> K-Maps for Flip-Flops -> Final Logic diagram.
- Compare logic families (TTL, CMOS, ECL) on propagation delay, power dissipation, noise margin, and fan-out.
- De Morgan's Laws: (A + B)' = A' B', (A B)' = A' + B'
- JK Flip-Flop Characteristic Equation: Q(next) = J Q' + K' Q
- D Flip-Flop: Q(next) = D; T Flip-Flop: Q(next) = T ⊕ Q
- Counter Flip-Flops: Number of flip-flops n for Mod-N counter: 2^(n-1) < N ≤ 2^n
- Noise Margin: NM_H = V_OH - V_IH, NM_L = V_IL - V_OL
Object Oriented Programming & Methodology
Object-oriented principles (encapsulation, abstraction, inheritance, polymorphism), C++ programming, classes, constructors/destructors, operator overloading, virtual functions, templates, STL, file I/O, and exception handling.
- Always write complete, syntactically accurate C++ code with class definitions, member functions, and main().
- Demonstrate operator overloading with both member functions and friend functions (e.g. overloading '+' or '<<').
- Explain the internal mechanism of runtime polymorphism using virtual pointer (vptr) and virtual table (vtable).
- Practice file handling with ifstream, ofstream, file opening modes (ios::in, ios::out, ios::app), and binary I/O.
- OOP Core Pillars: Encapsulation (data hiding), Abstraction (interface vs implementation), Inheritance (code reuse), Polymorphism (one interface, many forms)
- Dynamic Dispatch: vptr points to vtable array of function pointers. Resolved at runtime based on object's actual type
- Operator Overloading: ReturnType operator Symbol (ParameterList)
- Template Declaration: template <typename T> ReturnType FunctionName(T arg)
Energy & Environmental Engineering
Conventional and non-conventional energy resources, solar, wind, biomass, energy audit, environmental pollution (air, water, noise, soil), solid waste management, global environmental issues, and Environmental Impact Assessment (EIA).
- Draw neat functional block diagrams for renewable energy power systems: Solar PV, Wind Turbine, and Biogas Digester.
- Memorize air pollution control equipment: Cyclone separator, Electrostatic Precipitator (ESP), Fabric filters, and Wet Scrubbers.
- Understand BOD (Biochemical Oxygen Demand) and COD (Chemical Oxygen Demand) testing principles and dilution calculation formulas.
- Learn steps of Environmental Impact Assessment (EIA) and provisions of Environmental Protection Act 1986.
- Solar Electric Power: P = A * η * G (Watts), where A = panel area, η = efficiency, G = solar irradiance (W/m^2)
- Wind Power: P = 0.5 * ρ * A * v^3, where ρ = air density, A = swept area (π R^2), v = wind velocity (Betz limit = 59.3%)
- Biochemical Oxygen Demand: BOD = (DO_initial - DO_final) * Dilution Factor
- Noise Level in Decibels: dB = 10 * log10(I / I_0) = 20 * log10(P / P_0)
Mathematics-III
Numerical solutions of algebraic/transcendental equations, interpolation, numerical integration and ODEs, Fourier transform, Z-transform, probability distributions, hypothesis testing, and curve fitting.
- Practice iterative methods (Newton-Raphson, Gauss-Seidel) up to 3 or 4 decimal places with proper formula writing.
- For Runge-Kutta 4th order method, write down k1, k2, k3, k4 formulas cleanly and calculate intermediate points step-by-step.
- For probability distributions (Binomial, Poisson, Normal), write probability mass/density functions, mean, and variance.
- In hypothesis testing (t-test, Chi-square test, F-test), state Null Hypothesis H0, Alternative Hypothesis H1, degrees of freedom, and compare with critical value.
- Newton-Raphson: x_{n+1} = x_n - [f(x_n) / f'(x_n)]
- Simpson's 1/3 Rule: ∫ f(x)dx = (h/3) * [(y0 + yn) + 4*(y1 + y3 + ...) + 2*(y2 + y4 + ...)]
- Runge-Kutta 4th Order: y_{n+1} = y_n + (1/6)*(k1 + 2k2 + 2k3 + k4)
- Poisson Distribution: P(X = r) = (e^(-λ) * λ^r) / r!, Mean = Variance = λ
- Normal Distribution: Z = (X - μ) / σ, Standard Normal: μ = 0, σ = 1
- Z-Transform: Z{x[n]} = Σ_{n=-∞}^∞ x[n] z^(-n)
Analysis & Design of Algorithms
Asymptotic notation, recurrence analysis, divide-and-conquer, greedy method, dynamic programming, backtracking, branch-and-bound, string matching, and NP-completeness theory.
- State Master's Theorem equations clearly and test all three cases with recurrence problems.
- For Dynamic Programming problems (0/1 Knapsack, LCS, Matrix Chain), define the state, recurrence relation, and draw the 2D table.
- For Greedy algorithms (Huffman, Fractional Knapsack, Job Sequencing), explain greedy choice property and optimal substructure.
- Define P, NP, NP-Hard, and NP-Complete and draw the Venn diagram showing P != NP and P = NP possibilities.
- Master Theorem: T(n) = a T(n/b) + f(n). Compare f(n) with n^(log_b a). Case 1: Θ(n^(log_b a)), Case 2: Θ(n^(log_b a) log n), Case 3: Θ(f(n))
- 0/1 Knapsack DP: V[i, w] = max(V[i-1, w], v_i + V[i-1, w - w_i]) if w_i ≤ w else V[i-1, w]
- LCS DP: c[i, j] = c[i-1, j-1] + 1 if x_i == y_j else max(c[i-1, j], c[i, j-1])
- Matrix Chain Multiplication: m[i, j] = min_{i ≤ k < j} { m[i, k] + m[k+1, j] + p_{i-1} p_k p_j }
Operating Systems
Operating system services, process management, CPU scheduling, inter-process communication, synchronization, deadlocks, memory management (paging, segmentation, virtual memory), file systems, and I/O disk scheduling.
- Draw neat Gantt charts for CPU scheduling algorithms (FCFS, SJF, Priority, Round Robin) and show Turnaround and Waiting times in a table.
- For Banker's Algorithm, write out Allocation, Max, Available, and Need matrices, and show the Safe Sequence step-by-step.
- For Page Replacement (FIFO, LRU, Optimal), draw the page frame sequence and clearly indicate page faults and hits.
- Explain the Critical Section Problem requirements: Mutual Exclusion, Progress, and Bounded Waiting.
- Turnaround Time (TAT) = Completion Time (CT) - Arrival Time (AT)
- Waiting Time (WT) = Turnaround Time (TAT) - Burst Time (BT)
- Banker's Algorithm: Need[i, j] = Max[i, j] - Allocation[i, j]. Check: Need_i ≤ Available
- Effective Memory Access Time (EMAT) with TLB = HitRatio * (TLB_time + Mem_time) + (1 - HitRatio) * (TLB_time + 2 * Mem_time)
- Disk Scheduling: Seek Time = Total Head Movements * Time per cylinder
Software Engineering
Software process models (Waterfall, Spiral, Agile/Scrum), requirement engineering (SRS), software architectural design, UML modeling, software metrics, COCOMO estimation, testing strategies (black-box, white-box), and maintenance.
- Compare SDLC models (Waterfall, Prototype, Spiral, Agile Scrum) in neat tabular form highlighting risk, flexibility, and client involvement.
- Write standard IEEE 830 format sections for Software Requirements Specification (SRS).
- Draw UML diagrams (Use Case, Class, Sequence, Activity) for given real-life case studies (ATM, Library, E-commerce).
- Master Cyclomatic Complexity calculations: V(G) = E - N + 2P or V(G) = Predicate nodes + 1, and show basis paths.
- Basic COCOMO Model: Effort E = a * (KLOC)^b [person-months]; Development Time T_dev = c * (E)^d [months]
- Cyclomatic Complexity: V(G) = E - N + 2P (where E = edges, N = nodes, P = connected components) or V(G) = Predicates + 1
- Function Point: FP = UFP * [0.65 + 0.01 * Σ(F_i)] where UFP = Unadjusted Function Points
- Defect Density: Defect Density = Total Defected Found / Size of Software (KLOC)
Computer Organization & Architecture
Register transfer language, computer arithmetic (Booth's multiplication, division), control unit design (hardwired, microprogrammed), memory hierarchy, cache mapping, virtual memory, I/O organization (interrupts, DMA), and pipelining.
- Practice Booth's multiplication algorithm step-by-step with register tables (A, Q, Q_(-1), M) and arithmetic right shift.
- Solve cache memory mapping numericals: calculate tag, set/line, and word/offset bits for Direct, Associative, and Set-Associative mapping.
- Draw neat timing diagrams for pipelining and calculate pipeline speedup, efficiency, and throughput.
- Compare RISC and CISC architectures in tabular format with addressing modes, instruction sets, and pipelining ease.
- Booth's Bit Check: 00 -> No op, shift; 01 -> A = A + M, shift; 10 -> A = A - M, shift; 11 -> No op, shift
- Cache Average Memory Access Time: AMAT = HitTime + (MissRate * MissPenalty)
- Direct Mapping: Main Memory Address = Tag bits + Line/Index bits + Word/Offset bits
- Set-Associative Mapping: Main Memory Address = Tag bits + Set Index bits + Word Offset bits. Number of sets = Cache lines / Associativity
- Pipelining Speedup: S_k = (n * t_nonpipe) / ((k + n - 1) * t_pipe). For large n, Ideal Speedup S = k (number of stages)
Theory of Computation
Finite Automata (DFA, NFA, Moore/Mealy), regular expressions, pumping lemma for regular languages, Context-Free Grammars (CFG, CNF, GNF), Pushdown Automata (PDA), Turing Machines, decidability, and halting problem.
- Always draw neat transition diagrams and state transition tables with start state (arrow) and accept states (double circles).
- For NFA to DFA conversion, use the subset construction method and write the transition table clearly.
- Use the Pumping Lemma step-by-step: Assume L is regular, pick string w with |w| >= p, split into xyz, and show a pumped string xy^i z not in L.
- For Turing Machine design, define 7-tuple M = (Q, Σ, Γ, δ, q0, B, F) and provide transition table or state graph.
- DFA Definition: 5-tuple M = (Q, Σ, δ, q0, F) where δ: Q × Σ → Q
- Pumping Lemma (Regular): For any w ∈ L with |w| ≥ p, w = xyz such that |y| ≥ 1, |xy| ≤ p, and x y^i z ∈ L for all i ≥ 0
- Chomsky Hierarchy: Type 0 (Turing Machine / Unrestricted) ⊃ Type 1 (CSG / LBA) ⊃ Type 2 (CFG / PDA) ⊃ Type 3 (Regular / DFA)
- Chomsky Normal Form (CNF): A → BC or A → a (where A, B, C are non-terminals, a is terminal)
- Arden's Theorem: If P and Q are regular expressions and P does not contain ε, then R = Q + RP has unique solution R = Q P*
Database Management Systems
Database architecture, ER modeling, relational algebra, SQL (queries, subqueries, joins, views, triggers), normalization (1NF, 2NF, 3NF, BCNF), transaction processing, ACID properties, concurrency control, and database recovery.
- Draw complete ER diagrams with rectangles (entities), ellipses (attributes), diamonds (relationships), and primary keys underlined.
- For Normalization: Write functional dependencies (FDs), find candidate keys using closure algorithm (X+), and state whether 2NF, 3NF, or BCNF is satisfied with decomposition.
- Write syntactically correct SQL queries using SELECT, GROUP BY, HAVING, ORDER BY, and JOINs.
- Explain Two-Phase Locking (2PL), strict 2PL, and draw schedules demonstrating conflict serializability using precedence graphs.
- Closure Algorithm: To find X+, initialize X+ = X. Repeatedly add RHS of FD Y → Z if LHS Y ⊆ X+ until no more additions
- BCNF Condition: For every non-trivial FD X → Y, X must be a superkey
- 3NF Condition: For every non-trivial FD X → Y, either X is a superkey OR Y is a prime attribute
- Relational Algebra Operators: Select (σ), Project (π), Cartesian Product (×), Union (∪), Set Difference (-), Natural Join (⋈)
- Two-Phase Locking (2PL): Growing Phase (locks acquired, none released) -> Shrinking Phase (locks released, none acquired)
Cyber Security
Cyber threat landscape, attacks (malware, phishing, DoS/DDoS, XSS, SQLi), cryptographic foundations, symmetric/asymmetric ciphers, hashing, digital signatures, network security (firewalls, IDS/IPS, VPN), and IT Act 2000.
- Explain the CIA Triad (Confidentiality, Integrity, Availability) and Non-Repudiation with real-world examples.
- Understand Web Application Vulnerabilities from OWASP Top 10 (SQL Injection, XSS, CSRF, Broken Authentication).
- Explain the difference between Symmetric (AES, DES) and Asymmetric (RSA, ECC) encryption.
- Know key sections of India's Information Technology (IT) Act 2000 (Section 43, 65, 66, 66A-F, 72).
- CIA Triad: Confidentiality (Encryption, Access Control) + Integrity (Hashing, MAC) + Availability (Redundancy, DDoS Mitigation)
- RSA Key Generation: n = p*q, φ(n) = (p-1)(q-1). gcd(e, φ(n)) = 1. d ≡ e^(-1) mod φ(n). C = M^e mod n, M = C^d mod n
- Diffie-Hellman Key Exchange: Public prime q, generator α. Private keys X_A, X_B. Public keys Y_A = α^(X_A) mod q, Y_B = α^(X_B) mod q. Shared Secret K = (Y_B)^(X_A) mod q
- Hash Function Property: One-way (pre-image resistance), Weak collision resistance, Strong collision resistance
Internet & Web Technology
Web architecture, HTTP/HTTPS protocols, HTML5, CSS3, responsive design, JavaScript, DOM manipulation, asynchronous programming (AJAX, Promises, Fetch), XML/JSON, server-side scripting (PHP), and web security.
- Write complete, working HTML5 and CSS3 snippets with responsive layout (Flexbox/Grid) and media queries.
- Show JavaScript DOM manipulation code using getElementById, querySelector, addEventListener, and event delegation.
- Explain HTTP request-response lifecycle, HTTP methods (GET, POST, PUT, DELETE), and HTTP status codes (200, 301, 400, 404, 500).
- In PHP, demonstrate session management (session_start, $_SESSION), form handling ($_POST, $_GET), and MySQL database connectivity.
- CSS Box Model: Total Width = Width + Padding-Left/Right + Border-Left/Right + Margin-Left/Right
- HTTP Status Codes: 1xx Informational, 2xx Success (200 OK, 201 Created), 3xx Redirection (301, 302), 4xx Client Error (400, 401, 403, 404), 5xx Server Error (500, 502, 503)
- AJAX / Fetch Pattern: fetch(url).then(res => res.json()).then(data => handleData(data)).catch(err => handleError(err))
- PHP Session: session_start() must precede any HTML output. Data stored in $_SESSION['key']
Machine Learning
Supervised and unsupervised learning, linear regression, logistic regression, decision trees (ID3, CART), SVMs, Naive Bayes, ensemble methods (Random Forest, AdaBoost), clustering (K-Means), PCA, and neural networks with backpropagation.
- Derive the Mean Squared Error (MSE) cost function and Gradient Descent weight update equations for Linear Regression.
- For Decision Trees, calculate Entropy, Information Gain, and Gini Index with numerical examples.
- Explain the Support Vector Machine (SVM) maximum margin hyperplane equation and kernel trick.
- Draw the confusion matrix and define metrics: Accuracy, Precision, Recall, F1-Score, and ROC-AUC curve.
- Linear Regression Cost: J(w, b) = (1 / 2m) * Σ_{i=1}^m (h_w(x^(i)) - y^(i))^2
- Gradient Descent Update: w_j := w_j - α * (1/m) * Σ (h_w(x^(i)) - y^(i)) * x_j^(i)
- Logistic (Sigmoid) Function: g(z) = 1 / (1 + e^(-z))
- Entropy: H(S) = - Σ p_i * log2(p_i); Information Gain: IG(S, A) = H(S) - Σ (|S_v| / |S|) * H(S_v)
- Evaluation Metrics: Precision = TP / (TP + FP); Recall = TP / (TP + FN); F1 = (2 * P * R) / (P + R)
Computer Networks
Layered network architectures (OSI, TCP/IP), physical media, data link protocols (framing, error detection CRC, sliding window), MAC sublayer (CSMA/CD, Ethernet), network layer (IPv4/v6, subnetting, routing algorithms), transport layer (TCP, UDP, congestion control), and application layer protocols.
- Draw the 7 layers of OSI and 5 layers of TCP/IP model with data protocol units (Bits, Frames, Packets, Segments, Messages) and key protocols.
- Solve Subnetting numericals: calculate Network ID, Broadcast ID, Subnet Mask, and usable host address range.
- Trace Sliding Window protocols (Stop-and-Wait, Go-Back-N, Selective Repeat) with window size and transmission efficiency formulas.
- Compare Routing algorithms: Distance Vector Routing (Bellman-Ford, Count-to-Infinity) vs Link State Routing (Dijkstra, OSPF).
- Propagation Delay: T_prop = Distance / PropagationSpeed; Transmission Delay: T_trans = PacketSize / Bandwidth
- Sliding Window Efficiency: η = WindowSize / (1 + 2a), where a = T_prop / T_trans
- Subnetting: Number of subnets = 2^(subnet_bits), Usable hosts per subnet = 2^(host_bits) - 2
- CRC Division: Transmitted Frame = Data bits appended with (Degree of Generator) zeros, divided by Generator polynomial using XOR
- TCP Congestion Window: Slow Start (exponential growth cwnd = cwnd * 2) -> Congestion Avoidance (additive increase cwnd = cwnd + 1)
Compiler Design
Phases of a compiler, lexical analysis (LEX), top-down parsing (LL(1), FIRST and FOLLOW), bottom-up parsing (LR(0), SLR(1), CLR(1), LALR(1), YACC), syntax-directed translation, intermediate code generation, runtime environments, and code optimization.
- Draw the complete diagram showing all 6 phases of a compiler with inputs and outputs clearly annotated.
- Calculate FIRST and FOLLOW sets systematically: list all production rules and follow boundary conditions for ε.
- Construct LR parsing tables: compute canonical collection of items, write ACTION and GOTO tables, and resolve conflicts.
- For Three-Address Code, write Quadruples, Triples, and Indirect Triples representations for given arithmetic statements.
- Compiler Phases: Lexical Analyzer -> Syntax Analyzer -> Semantic Analyzer -> Intermediate Code Generator -> Code Optimizer -> Code Generator
- FIRST(α): Set of terminals that begin strings derived from α. If α =>* ε, then ε ∈ FIRST(α)
- FOLLOW(A): Set of terminals that appear immediately to the right of A in some sentential form. $ ∈ FOLLOW(S)
- LL(1) Condition: Grammar is LL(1) iff for every A → α | β, FIRST(α) ∩ FIRST(β) = ∅, and if ε ∈ FIRST(α), then FIRST(β) ∩ FOLLOW(A) = ∅
- Three-Address Code: Statement with at most three addresses: x = y op z or x = op y or x = y
Cloud Computing
NIST cloud definition, service models (IaaS, PaaS, SaaS), deployment models (Public, Private, Hybrid), virtualization technologies (Hypervisors, KVM, Docker, Kubernetes), cloud storage, resource scheduling, security, and AWS/Azure architectures.
- Compare Cloud Service Models (IaaS, PaaS, SaaS) and Deployment Models (Public, Private, Hybrid, Community) in structured comparison tables.
- Explain Server Virtualization: Type-1 (Bare-metal) vs Type-2 (Hosted) Hypervisors, Full Virtualization vs Paravirtualization vs Containers.
- Understand Containerization (Docker) and Container Orchestration (Kubernetes pods, services, deployments, ingress).
- Describe Service Level Agreements (SLA), availability calculations (99.99% 'four nines'), and cloud security responsibilities (Shared Responsibility Model).
- NIST 5 Essential Characteristics: On-demand self-service, Broad network access, Resource pooling, Rapid elasticity, Measured service
- Availability Formula: Availability = (Total Time - Downtime) / Total Time * 100%. 'Four Nines' (99.99%) allows 52.6 minutes downtime/year
- Shared Responsibility Model: SaaS (Cloud Provider manages all except data), PaaS (Customer manages data & apps), IaaS (Customer manages OS, middleware, runtime, apps, data)
Software Architecture & Design Patterns
Architectural styles (Layered, Pipe-and-Filter, Microservices, Event-Driven), GoF design patterns (Creational, Structural, Behavioral), architectural description languages, quality attributes, and Architecture Tradeoff Analysis Method (ATAM).
- Categorize GoF Design Patterns into Creational, Structural, and Behavioral patterns with code examples.
- Explain the SOLID design principles with bad design vs good design refactoring.
- Compare monolithic vs microservices architecture in terms of coupling, scaling, deployment, and data consistency.
- Describe the Architecture Tradeoff Analysis Method (ATAM) phases: Presentation, Investigation, and Evaluation.
- SOLID Principles: Single Responsibility (SRP), Open-Closed (OCP), Liskov Substitution (LSP), Interface Segregation (ISP), Dependency Inversion (DIP)
- Creational Patterns: Singleton, Factory Method, Abstract Factory, Builder, Prototype
- Structural Patterns: Adapter, Bridge, Composite, Decorator, Facade, Flyweight, Proxy
- Behavioral Patterns: Chain of Responsibility, Command, Iterator, Mediator, Memento, Observer, State, Strategy, Template Method, Visitor
- Quality Attributes (FURPS+): Functionality, Usability, Reliability, Performance, Supportability
Big Data Analytics & Distributed Systems
Big data characteristics (5 V's), Hadoop ecosystem (HDFS, MapReduce, YARN), Apache Spark (RDDs, DataFrames, Spark SQL, Spark Streaming), NoSQL databases, Hive, Pig, stream processing (Kafka), and distributed analytics.
- Explain the 5 V's of Big Data: Volume, Velocity, Variety, Veracity, and Value with practical examples.
- Draw the Hadoop HDFS architecture (NameNode, DataNodes, Secondary NameNode, Block replication) and describe block placement policy.
- Write MapReduce programs/pseudo-code (e.g. Word Count, Matrix Multiplication) with Mapper, Reducer, and Combiner functions.
- Explain Apache Spark Resilient Distributed Datasets (RDDs): Transformations (lazy evaluation) vs Actions, and compare with MapReduce.
- 5 V's of Big Data: Volume, Velocity, Variety, Veracity, Value
- HDFS Block Size: Default 128 MB. Default Replication Factor = 3 (Rack-awareness: 2 on local rack, 1 on remote rack)
- MapReduce Signature: Map: (k1, v1) -> list(k2, v2); Reduce: (k2, list(v2)) -> list(k3, v3)
- CAP Theorem: In any distributed data store, you can achieve at most two out of: Consistency (C), Availability (A), Partition Tolerance (P)
- Spark RDD Transformations: map, filter, flatMap, reduceByKey, groupByKey (Lazy). Actions: count, collect, take, reduce, saveAsTextFile
Cryptography & Network Security
Classical encryption techniques, block ciphers (DES, AES), public key cryptography (RSA, ECC), Diffie-Hellman key exchange, cryptographic hash functions (SHA-512), digital signatures, PKI, and network security protocols (IPsec, SSL/TLS, Kerberos).
- Practice RSA algorithm calculations step-by-step: compute n, φ(n), choose e, calculate private key d using Extended Euclidean algorithm.
- Trace Diffie-Hellman key exchange: write public parameters (q, α), private keys (X_A, X_B), public keys (Y_A, Y_B), and shared secret K.
- Explain the internal round functions of AES (SubBytes, ShiftRows, MixColumns, AddRoundKey) and DES (Feistel network, expansion, S-boxes).
- Explain IPsec architecture (AH vs ESP in Transport vs Tunnel modes) and SSL/TLS handshake protocol.
- Euler's Totient Function: For primes p and q, φ(p * q) = (p - 1) * (q - 1)
- Extended Euclidean Algorithm: a * x + b * y = gcd(a, b). Used to find modular inverse: d * e ≡ 1 (mod φ(n))
- RSA Encryption: C = M^e mod n; Decryption: M = C^d mod n
- Diffie-Hellman Shared Secret: K = (Y_B)^(X_A) mod q = (Y_A)^(X_B) mod q
- Digital Signature: Sign: S = M^d mod n; Verify: M = S^e mod n
Artificial Intelligence
Intelligent agents, uninformed search (BFS, DFS), informed heuristic search (A*, Greedy Best-First), adversarial games (Minimax, Alpha-Beta pruning), knowledge representation (First-Order Logic), probabilistic reasoning, and planning.
- In A* Search, write evaluation function f(n) = g(n) + h(n), explain heuristic admissibility (h(n) <= h*(n)) and consistency.
- For Minimax & Alpha-Beta Pruning, draw the game tree, label values at each MAX and MIN node, and show pruned branches clearly.
- Convert English statements into First-Order Predicate Logic (FOPL) and solve resolution refutation using CNF clauses.
- Explain the PEAS framework (Performance measure, Environment, Actuators, Sensors) for autonomous agents.
- A* Search Evaluation: f(n) = g(n) + h(n). Admissibility condition: 0 ≤ h(n) ≤ h*(n) (never overestimates true cost)
- Alpha-Beta Pruning: Prune when α ≥ β, where α = highest value seen so far for MAX, β = lowest value seen so far for MIN
- Bayes' Rule: P(A | B) = [P(B | A) * P(A)] / P(B)
- Resolution Rule: (A ∨ B) ∧ (¬A ∨ C) ⇒ (B ∨ C)
Soft Computing
Hard computing vs soft computing, artificial neural networks (Perceptron, Adaline, Madaline, Backpropagation, Hopfield, SOM), fuzzy logic (fuzzy sets, membership functions, defuzzification, fuzzy controllers), genetic algorithms, and hybrid neuro-fuzzy systems (ANFIS).
- Compare Hard Computing vs Soft Computing in a clear comparison table (tolerance for imprecision, uncertainty, partial truth).
- Draw neat diagrams for Artificial Neural Network architectures (Single-layer perceptron, Multi-layer perceptron with backpropagation).
- For Fuzzy Logic: Draw membership function graphs (triangular, trapezoidal) and calculate Defuzzified value using Centroid (Center of Gravity) method.
- For Genetic Algorithms: Outline the pipeline: Chromosome representation, Fitness function, Selection (Roulette Wheel), Crossover, Mutation.
- Perceptron Weight Update: w_i(new) = w_i(old) + η * (target - output) * x_i
- Fuzzy Union: μ_{A ∪ B}(x) = max(μ_A(x), μ_B(x)); Fuzzy Intersection: μ_{A ∩ B}(x) = min(μ_A(x), μ_B(x))
- Centroid Defuzzification: z* = [ Σ z * μ_C(z) ] / [ Σ μ_C(z) ] or [ ∫ z * μ_C(z) dz ] / [ ∫ μ_C(z) dz ]
- Roulette Wheel Selection Probability: P_i = f_i / ( Σ_{j=1}^N f_j )
- Hopfield Network Energy Function: E = -0.5 * Σ_i Σ_j w_{ij} s_i s_j - Σ_i θ_i s_i
Internet of Things
IoT architecture, physical/logical design, sensors, actuators, microcontrollers (Arduino, Raspberry Pi, ESP32), wireless protocols (RFID, BLE, ZigBee, LoRaWAN), application protocols (MQTT, CoAP, HTTP), cloud platforms, and smart application design.
- Draw the multi-layer IoT architecture (Perception layer, Network layer, Middleware layer, Application layer).
- Compare IoT application protocols: MQTT (Publish-Subscribe, Broker, QoS 0/1/2) vs CoAP (RESTful over UDP, Observe) vs HTTP in tabular format.
- Explain wireless sensor network technologies: Bluetooth Low Energy (BLE), ZigBee (IEEE 802.15.4), LoRaWAN, and 6LoWPAN.
- Describe embedded development platforms (Arduino Uno, ESP8266/ESP32, Raspberry Pi) with GPIO pinouts and sensor interfacing.
- IoT Protocol Stack: Physical/MAC (IEEE 802.15.4, BLE, LoRa) -> Network (IPv6 / 6LoWPAN, RPL) -> Transport (TCP / UDP) -> Application (MQTT, CoAP, HTTP, AMQP)
- MQTT QoS Levels: QoS 0 (At most once, no ack), QoS 1 (At least once, PUBACK required), QoS 2 (Exactly once, 4-step handshake: PUBLISH -> PUBREC -> PUBREL -> PUBCOMP)
- Friis Transmission Equation: P_r = P_t * G_t * G_r * (λ / (4 * π * d))^2
- LoRa Link Budget: Link Budget = P_tx - Sensitivity_rx (in dBm)
Data Mining & Warehousing
Data warehousing concepts, multidimensional models (Star, Snowflake schemas), OLAP operations, data preprocessing, association rule mining (Apriori, FP-Growth), classification (Decision trees, Naive Bayes, SVM), and cluster analysis (K-Means, DBSCAN).
- Differentiate between OLTP (Online Transaction Processing) and OLAP (Online Analytical Processing) in a neat comparison table.
- Draw Star Schema, Snowflake Schema, and Fact Constellation Schema with fact table, measures, and dimension tables.
- Practice Apriori algorithm step-by-step: Candidate generation (C_k), Support counting, and Pruning (L_k) to find frequent itemsets and association rules.
- Explain Data Preprocessing steps: Data Cleaning (handling missing values, noisy data), Integration, Transformation (normalization), and Reduction.
- Support(A → B) = Count(A ∪ B) / Total_Transactions
- Confidence(A → B) = Count(A ∪ B) / Count(A) = Support(A ∪ B) / Support(A)
- Lift(A → B) = Confidence(A → B) / Support(B) = P(A ∩ B) / (P(A) * P(B)). Lift > 1 indicates positive correlation
- K-Means Euclidean Distance: d(p, q) = √[ Σ_{i=1}^n (p_i - q_i)^2 ]
- Min-Max Normalization: v' = [ (v - min) / (max - min) ] * (new_max - new_min) + new_min
No subjects found
Try refining your search query or switching semesters.