Bihar STET 2023 Computer Science Shift 1 Question Paper (With Answers & Explanations)

✅ K-map grouping of minterms leads to five simplified product terms. ✅ Option (A) correctly represents all minimized groups from the K-map. ✅ The function cannot be further reduced without losing coverage.

A Programmable Logic Array has a programmable AND array followed by a programmable OR array. Product terms are formed in the AND plane and summed in the OR plane to realize SOP functions. This architecture lets you implement multiple outputs sharing common product terms efficiently.

The accumulator stores one operand and the intermediate/final result of ALU operations. Most single-address instruction sets implicitly use the accumulator. This reduces instruction bits and speeds repetitive arithmetic/logic sequences.

CMOS technology combines complementary enhancement MOSFETs (nMOS & pMOS). Depletion devices can be used as loads/biasing elements in some CMOS processes. CMOS offers low static power, high noise margins, and dense VLSI integration.

ROM retains data without power and holds firmware/boot code; typical users cannot alter it at runtime. RAM is volatile working memory used by the CPU for active data and instructions. Hence ROM = permanent (non-volatile), RAM = temporary (volatile read-write).

The minterms correspond to cells where F=1; grouping via K-map yields simplified SOP. Combining common implicants leads to A’B’ + AB’ + AB + AC. This expression covers all listed minterms with minimal redundancy.

In end-around carry methods (e.g., some 1’s-complement schemes), carry-out is added back to LSB. This produces the correct wrapped sum when using that arithmetic. Discarding the carry is used in standard unsigned binary; here LSB addition is specified.

The process mirrors long multiplication: start with the multiplier’s LSB and generate a partial product. Shift left for each higher bit and add partial products. This ensures correct positional weighting of each bit’s contribution.

Hamming codes position parity bits at powers of two to cover disjoint sets. Greater separation and proper coverage improve detect/correct abilities. If parity bits are “closer” (overlapping poorly), correction capability is reduced.

Gray→Binary conversion uses cumulative XOR: keep MSB same, then XOR each next Gray bit with previous Binary bit. This property follows from Gray code’s 1-bit adjacency. The XOR chain efficiently reconstructs the binary sequence.

Main memory (RAM) stores active instructions and data for the CPU. The ALU executes operations; CPU orchestrates fetch-decode-execute; I/O handles peripherals. Volatile RAM enables fast, random access needed for processing.

Data bus width equals the number of bits transferable in parallel per cycle. Wider buses allow moving larger words (e.g., 32/64-bit). Address bus width, not asked here, determines addressable memory space.

ECUs use microcontrollers to manage ignition, fuel injection, and sensors. Real-time control, low power, and integrated peripherals suit automotive needs. Many subsystems (ABS, airbags) also rely on MCUs.

Hash tables allocate buckets and manage collisions (e.g., chaining/probing). With good hashing, average search/insert/delete is O(1). The extra bucket overhead yields speed gains on average cases.

A tradeoff explicitly balances competing factors (e.g., time vs space). Algorithm design often optimizes one metric at the cost of another. Recognizing tradeoffs guides practical, context-aware solutions.

Some algorithms perform differently on “structured” vs “arbitrary” inputs. Conditional notation captures performance under stated assumptions. It communicates realistic bounds beyond worst-case O(·).

The conditional little-o bound reduces to the same little-o without the guard. Little-o means strictly smaller order than f(n) as n→∞. Thus, the unconditional expression is simply o(f(n)).

The recurrence halves the problem size each step with O(1) combine cost. This pattern is classic Divide-and-Conquer (e.g., binary search). Solution is O(log n) by expanding levels or Master Theorem.

Problems are split into subproblems, solved recursively, then merged. Examples include merge sort, quicksort, and FFT. Recursion captures the repeated structure elegantly.

Threads replace null pointers with links to inorder predecessor/successor. This enables traversal without recursion or stacks. It reduces overhead while preserving binary tree structure.

DFS uses a stack (explicit or via recursion) to backtrack. BFS relies on a queue to explore level by level. Stack-based DFS is natural for path exploration.

Ordered pair (A,B) indicates a directed arc from A to B. Unordered sets like {A,B} represent undirected edges. Ordered notation matters for directionality.

Each bucket maintains a linked list (or similar structure) of entries. This allows O(1) average insert and flexible growth. Memory overhead increases but simplifies deletion.

Linear probing scans sequential slots until a free one is found. It’s cache-friendly but suffers from primary clustering. Quadratic and double hashing reduce clustering differently.

Recurrence T(n)=2T(n−1)+1 solves to T(n)=2^n−1. Each move splits problem into moving n−1 disks twice around the largest disk. The exponential pattern reflects doubling subproblems plus one move.

Iterative versions use loops and sometimes an explicit stack. Tail recursion elimination is a classic case converting to a loop. This reduces call overhead and can improve performance.

Formal models define subjects, objects, and access rights rigorously. They enable verification of safety properties and policies. Bell-LaPadula and Biba are classic examples of such frameworks.

Buffer cache holds recently accessed disk blocks to reduce I/O latency. It exploits temporal/spatial locality and merges writes. This improves throughput and perceived file system speed.

Core file ops are create, open, read, write, append, rename, and delete. The OS provides system calls and permissions to manage them. Memory and CPU register handling are separate concerns.

The I/O subsystem abstracts device specifics, schedules requests, and handles drivers. It provides buffered, asynchronous, and interrupt-driven transfers. File systems sit above block I/O; CPU scheduling is separate.

Keep the flow going—consistent practice builds pattern recognition and speed. When you’re ready, paste the next block (Q31–Q50) below. Want me to send Q31–Q50 now in the same format? Say: “Send Q31–Q50”.

Load control (admission and degree of multiprogramming) aims to keep the system responsive and fair. By balancing runnable processes, the scheduler can distribute CPU share more evenly. This prevents overload/thrashing and improves overall throughput and user experience.

The page table maps a process’s virtual page numbers to physical frame numbers. During address translation, the MMU consults this mapping (often via TLB for speed). This indirection enables isolation, protection, and flexible memory allocation.

Fixed partitions cause external fragmentation and poor fit when process sizes vary. A process larger than any partition cannot be loaded, wasting space in others. Dynamic schemes (variable partitions, paging) mitigate such fragmentation issues.

A Database Management System provides structured storage and controlled access to data. It supports CRUD operations, concurrency, recovery, and integrity constraints. SQL is the language used with a DBMS; the DBMS itself is the software engine.

Concurrency control relies on locking (and related protocols) to preserve isolation and consistency. Locks coordinate overlapping reads/writes across transactions to avoid anomalies. Triggers/cursors have other roles; pointers are a low-level notion outside ACID control.

NTFS (New Technology File System) is a modern Windows file system that supports large files, security permissions, encryption, and journaling for reliability. It replaced older FAT systems and is optimized for performance and data protection.

Specialization is a top-down process where a general entity is divided into more specific sub-entities. For example, the entity “Vehicle” may specialize into “Car” and “Bike.” It is commonly used in database design and object-oriented modeling.

A Data Flow Diagram (DFD) visually represents how data moves through a system. It shows inputs, outputs, storage points, and data-processing steps. Widely used in system analysis for understanding process flow.

FAT (File Allocation Table) is a simple file system structure used by DOS and older Windows systems. It keeps track of which areas of storage are used and which are free. Though outdated now, it was widely used for USB drives and SD cards.

Data refers to raw, unprocessed facts and figures without any context or meaning. When data is processed and interpreted, it becomes information. Thus, raw numeric or textual values are considered data.

Routing determines the optimal path for packets from source to destination. It uses routing tables and algorithms like Dijkstra or Bellman-Ford. This is a core responsibility of the network layer in the OSI model.

A socket is an endpoint for communication between two processes over a network. It pairs an IP address with a port number for TCP/UDP-based communication. Applications use sockets to send and receive data.

Parallel transmission sends multiple bits at once over multiple communication lines. It is faster than serial transmission but more expensive and suitable for short distances. Printers historically used parallel ports for this reason.

Star, Ring, and Mesh are valid network topologies. “Disk” is not a recognized topology in networking. Network topology refers to how nodes are physically/logically arranged.

Ethernet networks often use CSMA/CD (Carrier Sense Multiple Access with Collision Detection). It allows devices to contend for access and detect collisions. This is efficient for broadcast networks with shared media.

Routing selects the most efficient path for forwarding packets across networks. Routers maintain routing tables using algorithms like RIP or OSPF. It is a fundamental role of the network layer in the OSI model.

ARP converts IP addresses to their corresponding MAC addresses on local networks. It enables devices within a LAN to locate each other at the data link layer. Without ARP, Ethernet-based communication would not be possible.

The Spiral Model combines iterative development with risk analysis in each phase. It is best suited for large, high-risk projects requiring refinement through cycles. Each loop evaluates risks, prototypes solutions, and moves toward completion.

SQA defines procedures and standards ensuring software development follows best practices. It focuses on prevention of defects through robust processes rather than final inspection alone. It builds reliability and customer trust over time.

Reverse engineering helps understand the internal structure and functionality of existing software. It is often used for documentation, maintenance, and analyzing legacy or competitor systems. This is especially useful when source code is unavailable.

Consistency leads to mastery. Keep going and boost your chances of cracking STET with confidence! Say “Send Q51–Q60” to continue the next batch.

Unit testing validates small, isolated pieces of code (functions, classes) in isolation. It enables quick feedback, easier debugging, and supports test-driven development (TDD). Mocks/stubs are often used to isolate external dependencies.

System testing evaluates the complete, integrated system against requirements. It examines end-to-end flows, environment behavior, and non-functionals. This stage simulates real-world usage before acceptance testing.

Function Point Analysis estimates size by quantifying features (inputs, outputs, files, interfaces). It’s technology-agnostic and useful for cost, effort, and schedule estimation. It complements models like COCOMO for planning.

Staffing models (e.g., Putnam-Norden-Rayleigh) relate manpower over time to project dynamics. While the question’s keying emphasizes risk focus, realistically staffing also supports resource allocation. Proper estimation mitigates schedule risk and boosts delivery confidence.

Many OOP languages (Java, C#, C++) use new to allocate and initialize objects. Some languages differ (e.g., Python calls the class, Go uses make/new), but for this context, new is standard. It binds memory allocation with constructor invocation.

An abstract class defines a common template (often with abstract methods) and cannot be directly instantiated. Subclasses provide concrete implementations. It supports code reuse and enforces a design contract.

super accesses superclass members or invokes its constructor. It resolves member shadowing and enables proper initialization in inheritance chains. Useful for extending behavior while reusing base logic.

A class encapsulates data (fields) and behavior (methods) as a reusable blueprint. Objects are concrete instances created from the class. This abstraction supports modularity and reuse.

Information hiding conceals internal implementation details behind stable interfaces. Clients depend only on what is necessary, improving maintainability and safety. Encapsulation enables it; abstraction complements it conceptually.

Inheritance lets a class acquire properties and behaviors of another, enabling reuse and hierarchy. It helps model “is-a” relationships and supports polymorphism. Proper design avoids tight coupling and fragile bases.

Ready for the next stretch of MCQs with crisp explanations? Say “Send Q61–Q70” to continue.

Fixed partitioning splits memory into predetermined blocks. When a program doesn’t fit any partition, space elsewhere goes unused, and poor fits cause wasted gaps. This is classic external fragmentation; dynamic schemes reduce this problem.

The MMU uses the page table to map a process’s virtual page numbers to physical frames. Caching this mapping in a TLB speeds up translation. This indirection enables isolation, relocation, and protection.

Load control regulates the degree of multiprogramming so the scheduler can share CPU fairly. By avoiding overload and thrashing, overall responsiveness improves. It balances throughput and fairness across runnable jobs.

The I/O subsystem abstracts device specifics, handles buffering, caching, and scheduling. Drivers and interrupts provide efficient communication with peripherals. File systems build on block I/O; CPU scheduling is separate.

Core file operations are create/open, read/write/append, rename, and delete. The OS enforces permissions and consistency while apps use system calls. Register loading is unrelated to file manipulation.

Formal protection models specify subjects, objects, and rights with rigorous semantics. They allow verification of safety properties and policy enforcement. Examples include the Bell–LaPadula and Biba integrity models.

Threads replace null pointers with links to inorder predecessor/successor. This supports traversal without recursion or an auxiliary stack. It saves time/space at the cost of extra link maintenance.

Iterative solutions use loops, often with an explicit stack simulating call frames. Tail recursion can be converted directly into loops by compilers or by hand. This avoids call overhead and can improve performance.

The recurrence T(n)=2T(n−1)+1 solves to T(n)=2^n−1. Each step moves the top n−1 disks twice around the largest disk. The exponential growth reflects duplicated subproblems at each level.

Linear probing linearly scans subsequent slots until a free one is found. It’s cache-friendly but prone to primary clustering. Quadratic probing and double hashing reduce clustering differently.