ISRO Scientist/Engineer SC (Computer Science) study plan

Implement from scratch in C a dynamic array, singly and doubly linked list, array-based and linked stack, and a circular queue; test each against edge cases (empty, single element, full, wraparound).

Tabulate the best/average/worst-case time and space complexity of every operation you implemented and justify each entry in one sentence.

Hand-trace recursion examples (factorial, Tower of Hanoi, decimal-to-binary, Ackermann for small inputs) by drawing the full call stack and counting calls.

Convert infix to postfix/prefix and evaluate postfix expressions by hand for 10 mixed-operator expressions with parentheses.

Solve 40 MCQs on arrays, linked lists, stacks, queues and hashing basics, and log every wrong answer with the corrected rule.

Implement BST insert/delete/search (all three delete cases), min-heap insert/delete, and all five traversals; state worst-case complexity of each and when it degrades.

Solve 30 MCQs on tree/heap properties: node count vs height bounds, AVL rotation identification, complete-binary-tree array indexing, heapify cost, and open vs chained hashing collision behaviour.

Convert numbers among binary, octal, decimal and hexadecimal; compute 1's and 2's complement and state the signed range for 8-, 16- and 32-bit words.

Simplify 20 Boolean expressions with Karnaugh maps (including don't-care conditions) and redraw each result using only NAND gates, then only NOR gates.

Design and analyse flip-flop circuits: mod-N ripple and synchronous counters, ring and Johnson counters, and shift registers; write the state table and excitation table for each.

Compute cache behaviour for direct-mapped, set-associative and fully associative caches: split addresses into tag/index/offset, calculate hit ratio and AMAT, and classify compulsory, capacity and conflict misses.

Analyse a 5-stage pipeline: compute speedup, CPI with stalls, and identify data, control and structural hazards with the forwarding or stalling fix for each.

Prove or disprove set identities, check whether a given relation is reflexive/symmetric/transitive, identify posets, lattices and groups, and negate quantified statements correctly.

Solve 30 MCQs on computer organization and 25 on discrete mathematics, logging every formula you had to look up.

Solve 15 recurrences using the Master Theorem and the substitution method, and state which case applies and why.

Hand-trace Dijkstra, Bellman-Ford, Prim, Kruskal and Floyd-Warshall on small weighted graphs; state complexity, correctness preconditions and which graph types break each algorithm.

Contrast dynamic programming with greedy for LCS, 0/1 vs fractional knapsack, matrix-chain multiplication and coin change; write the recurrence and base case for each.

Solve counting and graph-theory problems: pigeonhole, permutations with repetition, inclusion-exclusion, Euler/Hamiltonian path tests, chromatic number, and spanning-tree counting.

Take a 90-minute timed set of 40 algorithm and 20 discrete-mathematics questions and produce an error analysis grouped by cause.

Construct DFAs and NFAs for 10 given languages, convert two NFAs to DFAs by subset construction, and minimise one DFA using table filling.

Apply the pumping lemma to prove non-regularity for regular-looking languages and to prove non-context-freeness for at least two languages; list closure properties of regular and context-free languages.

Design PDAs for three languages and Turing machines for two, then place each language in the Chomsky hierarchy and classify it as regular, CFL, recursive or recursively enumerable.

Build an LL(1) parsing table using FIRST/FOLLOW sets and an SLR(1) table using LR(0) items; identify and explain every conflict that arises.

Generate three-address code and basic blocks for a given code fragment, build its DAG, and mark common subexpressions, dead code and loop-invariant statements.

Compute waiting, turnaround and response times for a 5-process set under FCFS, SJF, SRTF, round-robin and priority scheduling, drawing the Gantt chart for each.

Write semaphore or monitor solutions for producer-consumer, readers-writers and dining philosophers, and check each against the four deadlock conditions.

Apply Banker's algorithm to a given allocation/available matrix to find a safe sequence, and identify the request that must be denied.

Compute effective access time with TLB and page faults, and count page faults under FIFO, LRU and Optimal for a given reference string; detect Belady's anomaly.

Compute total head movement for FCFS, SSTF, SCAN, C-SCAN and LOOK disk scheduling on the same request queue.

Normalise six relations to 3NF and BCNF: compute attribute closures and candidate keys, show each violated FD, and verify the decomposition is lossless and dependency-preserving.

Write and actually run 30 SQL queries covering multi-table joins, GROUP BY/HAVING, nested and correlated subqueries, views and triggers; give the relational-algebra form of five of them.

Analyse B+ tree order and index choice for given queries, and explain 2PL, timestamp ordering, isolation levels and log-based recovery with checkpoints on a small schedule.

Draw ER, DFD and use-case diagrams for a supplied problem statement, compute cyclomatic complexity from a flow graph, and map out unit/integration/system/acceptance testing responsibilities.

Solve 20 numerical networking problems: CIDR subnetting, CRC generation and checking, checksum, sliding-window efficiency, CSMA/CD minimum frame size, token bucket and TCP congestion window growth.

Trace TCP's three-way handshake and state transitions, compare TCP and UDP headers, work through IP fragmentation, and order the steps of ARP, DHCP and DNS resolution against the OSI and TCP/IP layers.

Distinguish static vs dynamic scoping, value vs reference vs name parameter passing, and type checking vs coercion; write and read small HTML/CSS/JavaScript/XML/JSON snippets and explain HTTP methods, status codes and servlet/JSP lifecycle.

Complete two full-length timed mocks of 90 minutes spanning all ten domains, then compress every remaining formula and definition into a single revision page for the last day.