Question 1

Among common storage media, which one is inherently sequential-access only (i.e., cannot provide true random access to arbitrary records)?

Accepted Answer

Introduction / Context: Data access patterns vary across storage media. Understanding whether a medium supports random access or only sequential access is crucial for system performance planning and archival design. Given Data / Assumptions: 'Sequential access' means data must be read in order until the desired location is reached. 'Random access' means the device can reposition quickly to access any block directly. Typical devices: floppy disk, hard disk, ROM, and magnetic tape. Concept / Approach: Magnetic tape stores data linearly along a long strip. To reach a given record, the tape must be wound forward or backward to that location—this is sequential by nature. Disks (floppy/hard) use addressable tracks and sectors, enabling near-random access. ROM is also random access by address lines. Step-by-Step Solution: Identify media with mechanical linear scanning → magnetic tape.Disks/ROM provide addressable blocks → random access.Therefore, magnetic tape is sequential-only. Verification / Alternative check: Backup/archival systems based on LTO tape require tape positioning and are optimized for streaming throughput rather than random I/O, confirming sequential semantics. Why Other Options Are Wrong: Floppy/Hard disks: random access via seek and rotational latency. ROM: direct addressing supports random fetches. Flash drive: solid-state storage with random access. Common Pitfalls: Confusing file system behavior over a medium with the medium's physical access method; even if a file is fragmented, disks remain random-access media. Final Answer: Magnetic tape

Question 2

In the classic 4-bit ALU IC 74181, arithmetic addition and subtraction operations are effectively carried out in which number system representation?

Accepted Answer

Introduction / Context: The 74181 is a classic TTL 4-bit arithmetic logic unit that implements a variety of logic and arithmetic functions. Understanding how subtraction is realized clarifies the number representation effectively supported by the chip in typical CPU designs. Given Data / Assumptions: 74181 provides arithmetic functions including A + B and A + Ā + 1 (which can represent A − B). Carry-in (Cn) control is available to facilitate two’s-complement subtraction. Outputs include sum and carry allowing ripple-carry extension across nibbles. Concept / Approach: Two’s-complement subtraction A − B is implemented as A + (two’s complement of B) = A + (B̄ + 1). The 74181 can complement one operand and accept a carry-in of 1, thereby performing subtraction through addition, which is the standard two’s-complement technique. Step-by-Step Solution: Set the function for addition mode.Select operand B complemented and set carry-in Cn = 1.Operation executed: A + B̄ + 1 = A − B (two’s complement arithmetic).Thus, the ALU supports two’s-complement add/sub semantics. Verification / Alternative check: Manufacturer datasheets show function tables enabling addition with complemented inputs and carry-in, confirming two’s-complement subtraction support across cascaded 74181 stages for wider word lengths. Why Other Options Are Wrong: 1’s complement: Would require end-around carry handling; not how 74181 subtraction is normally configured. Binary (unsigned only): The same hardware supports signed arithmetic via two’s complement interpretation. 'none of the above' / 'excess-3': Not applicable to 74181 arithmetic modes. Common Pitfalls: Assuming a separate subtractor is required; misunderstanding that complement-and-add with carry-in is precisely the two’s-complement method. Final Answer: 2's complement

Question 3

In basic computer literacy, identify which of the following is an actual computer programming language rather than an application package.

Accepted Answer

Introduction / Context: Learners often confuse application software with programming languages. This question checks the fundamental distinction between end-user tools (word processors, spreadsheets, desktop publishing) and a formal language used to instruct a computer to perform computations. Given Data / Assumptions: MS WORD and MS EXCEL are Microsoft Office applications for documents and spreadsheets. PageMaker is a desktop publishing application. LISP is historically one of the oldest high-level programming languages. No prior code examples are required; the task is classification. Concept / Approach: Programming languages provide syntax, semantics, and control structures (e.g., functions, recursion) to create algorithms and software. Application programs provide ready-made functionality to create content but are not languages themselves. Some apps expose scripting, but the app is still not itself a language. Step-by-Step Solution: List each option and determine its category.MS WORD → word processing software (application).PageMaker → desktop publishing application (application).MS EXCEL → spreadsheet application (application).LISP → high-level programming language widely used in AI and symbolic computation.Therefore, the only programming language in the list is LISP. Verification / Alternative check: Any introductory CS text lists LISP alongside C, Java, and Python as languages; Microsoft Office programs are consistently categorized as applications, not languages. Why Other Options Are Wrong: MS WORD: Tool for editing text documents, not a programming language. PageMaker: Tool for page layout; again not a language. MS EXCEL: Spreadsheet application; while it has formulas/VBA, Excel itself is not a language. PowerPoint: Presentation software; not a language. Common Pitfalls: Assuming that because an app allows macros or scripting, the app becomes a language. The language is the scripting engine (e.g., VBA), not the application brand. Final Answer: LISP

Question 4

During execution, where does a computer hold instructions, data, intermediate results, and final results for fast access?

Accepted Answer

Introduction / Context: Understanding the memory hierarchy is fundamental in computer organization. While the CPU executes operations, it continuously fetches instructions and reads/writes data to a fast store. Identifying this store clarifies how performance and data flow are managed. Given Data / Assumptions: The system is a conventional von Neumann architecture. We distinguish between CPU (processing unit) and memory (storage). Intermediate and final results must be quickly accessible to the processor. Concept / Approach: Main memory (RAM) is the working area holding program code, data, and temporary results during execution. The CPU contains small internal registers and often uses cache (a small, fast part of primary memory hierarchy). Secondary memory (e.g., disk) is for long-term storage, not active computation due to latency. Step-by-Step Solution: Identify which component stores data and instructions during processing.CPU executes; ALU performs arithmetic/logic but does not store large datasets.Primary memory (RAM) holds instructions, data, and results for quick access.Secondary memory is too slow and is used for persistence, not active steps. Verification / Alternative check: Any OS task manager shows programs loaded into RAM; CPU registers/cache are part of the main memory hierarchy used for speed but the bulk of working data resides in primary memory during execution. Why Other Options Are Wrong: CPU / ALU: Processing units, not bulk storage; they use registers but cannot hold all program data/results. Secondary memory: Persistent storage; too slow for instruction-by-instruction access. “Cache on the hard drive”: Misconception; disk caches exist but are not where the CPU actively holds working sets. Common Pitfalls: Confusing CPU registers with system memory; assuming that “the CPU has the data” means the CPU stores everything. It relies on RAM and caches. Final Answer: Primary memory (main memory / RAM)

Question 5

When adding normalized floating-point numbers 0.4546 × 10^5 and 0.5433 × 10^7, which alignment step is performed before addition?

Accepted Answer

Introduction / Context: Floating-point addition requires aligning exponents so that the significands (mantissas) can be added. This step is core to understanding how CPUs implement IEEE-754 style arithmetic and why precision can be lost when magnitudes differ widely. Given Data / Assumptions: Numbers: 0.4546 × 10^5 and 0.5433 × 10^7 (already normalized). Base-10 notation used for clarity; same idea applies in base-2. We want to perform addition, not multiplication. Concept / Approach: For addition, convert the number with the smaller exponent to the larger exponent by shifting the radix point (dividing its significand by the appropriate power of 10). This keeps relative value while making exponents equal. Step-by-Step Solution: Compare exponents: 10^5 vs 10^7 → the second is larger.Raise the first number’s exponent from 10^5 to 10^7: multiply by 10^2 in the exponent; divide significand by 10^2.0.4546 × 10^5 = 0.004546 × 10^7 (move decimal two places left).Now add: (0.004546 + 0.5433) × 10^7 after alignment. Verification / Alternative check: Converting the second to 10^5 would require moving the decimal right two places (54.33 × 10^5), which breaks normalized form and risks overflow in fixed-width mantissa; standard practice is to align the smaller exponent upward. Why Other Options Are Wrong: No change: impossible—exponents differ. Changing 0.5433 × 10^7 to 54.33 × 10^5: de-normalizes the number unnecessarily. Forcing both to 10^6: not required and wastes precision. Changing to 10^9 arbitrarily: irrelevant to addition here. Common Pitfalls: Forgetting to shift the significand in the opposite direction to the exponent change; adding significands without alignment, leading to large error. Final Answer: 0.4546 × 10^5 is changed to 0.004546 × 10^7 and 0.5433 × 10^7 is not changed

Question 6

In C-style increment semantics, the expression ++i is functionally equivalent to which assignment update?

Accepted Answer

Introduction / Context: Operators ++ and -- are syntactic sugar in C, C++, Java, and many other languages for common increment/decrement operations. Recognizing their equivalence to explicit assignment helps avoid off-by-one errors and clarifies pre- vs post-increment behavior in expressions. Given Data / Assumptions: Variable i is numeric (typically integer). We focus on the effect on i itself, not on expression value in larger contexts. Pre-increment (++i) updates i before using it in any surrounding expression. Concept / Approach: The core semantics of ++i are to increase the stored value of i by one unit. As a stand-alone statement (++i;) this is equivalent to i = i + 1;. In compound expressions, ++i yields the updated value, while i++ yields the previous value. Step-by-Step Solution: Identify the increment amount: +1.Express as assignment: i = i + 1.Note: Pre-increment returns the new value; post-increment returns the old value. The update to i is +1 in both forms.Therefore, ++i ≡ i = i + 1 for updating i. Verification / Alternative check: Consider i = 5; ++i makes i = 6. Using i = i + 1 also makes i = 6. In a context like j = ++i;, j becomes 6; with j = i++; j becomes 5 though i becomes 6 afterward. The update magnitude remains +1. Why Other Options Are Wrong: i = i + 2: Adds two, not one. i = i − 1: Decrement, opposite effect. i = i + i + i: Triples i, not an increment. i = 1 + 1/i: Unrelated arithmetic. Common Pitfalls: Confusing pre-increment with post-increment in expressions; assuming ++i always equals i++ in value position—only the side effect on i matches (+1). Final Answer: i = i + 1

Question 7

FORTRAN computed GO TO: Given JCOKE = 3; JCOKE = JCOKE + 1; GO TO (5, 8, 9, 11, 15, 16, 18, 20) JCOKE. To which statement label is control transferred?

Accepted Answer

Introduction / Context: Classical FORTRAN provides a computed GO TO statement for multi-way branching: GO TO (L1, L2, …, Ln) k transfers control to the k-th label in the list. Understanding the indexing behavior is essential for reading legacy scientific code. Given Data / Assumptions: Initial JCOKE = 3. JCOKE is incremented by 1 before the computed GO TO. Label list is (5, 8, 9, 11, 15, 16, 18, 20) in that order. Indexing is 1-based (k = 1 selects the first label). Concept / Approach: Evaluate JCOKE after the increment, then index into the label list. Out-of-range indices typically fall through (implementation dependent), but here the index is within the valid range 1..8. Step-by-Step Solution: Start: JCOKE = 3.Execute JCOKE = JCOKE + 1 → JCOKE becomes 4.Computed GO TO picks the 4th label in the list.List positions: 1→5, 2→8, 3→9, 4→11, 5→15, 6→16, 7→18, 8→20.Thus, control transfers to label 11. Verification / Alternative check: Trace as if it were an array: labels[4] = 11. This matches standard FORTRAN behavior. Why Other Options Are Wrong: 8 and 9: Correspond to indices 2 and 3, not 4. 16 and 20: Correspond to indices 6 and 8, respectively. Common Pitfalls: Assuming zero-based indexing; forgetting the prior increment of JCOKE; miscounting label positions. Final Answer: 11

Question 8

In typical microcomputers, what is the usual size order of on-chip or external cache memory?

Accepted Answer

Introduction / Context: Cache memory bridges the speed gap between the CPU and main memory. Historically, in microcomputer contexts (especially classic microprocessors and embedded systems), cache was limited in size but very fast. Recognizing these typical magnitudes helps set realistic expectations for resource-constrained systems. Given Data / Assumptions: We refer to “most microcomputers” in the classical/embedded sense, not modern desktop CPUs with multi-MB caches. Cache is smaller and faster than RAM. Technology generations vary; the question targets the usual small cache regime. Concept / Approach: Early and many embedded microcomputers provided small caches on the order of kilobytes to minimize die area and power while still improving performance; megabyte-scale caches are common in modern desktop/server CPUs but exceed the “microcomputer” notion in classical curricula. Step-by-Step Solution: Eliminate implausible sizes: “a few bytes” is too small to be effective.“A few gigabytes” is characteristic of RAM/storage, not cache.“A few megabytes” suits modern high-end CPUs but not typical microcontrollers/microcomputers historically discussed.Therefore, “a few kilobytes” aligns with typical small on-chip caches. Verification / Alternative check: Examples: Many microcontrollers and older microprocessors (e.g., early ARM/MIPS cores) ship with L1 caches ranging from 1 KB to tens of KB per instruction/data side in basic configurations. Why Other Options Are Wrong: Bytes: negligible benefit. Megabytes/Gigabytes: out of scope for “most microcomputers” in foundational courses. Common Pitfalls: Projecting modern desktop CPU cache sizes onto embedded/classic microcomputer contexts; confusing cache with RAM. Final Answer: a few kilobytes

Question 9

8085 microprocessor: “The temporary register in 8085 is a 16-bit register.” Evaluate the statement.

Accepted Answer

Introduction / Context: Internal registers of the Intel 8085 include 8-bit general-purpose registers (B, C, D, E, H, L, A), a 16-bit program counter and stack pointer, and some internal temporary registers. Distinguishing their widths is important for assembly and micro-architecture understanding. Given Data / Assumptions: 8085 has 8-bit data bus and 16-bit address bus. General-purpose registers are 8-bit, pairable to form 16-bit operands (e.g., HL, BC, DE). Internal temporary registers (often denoted W and Z) are 8-bit each but can be used as a 16-bit pair. Concept / Approach: The phrase “the temporary register is 16-bit” suggests a single 16-bit register. In 8085, the internal temporary storage commonly referenced consists of two 8-bit registers (W and Z) used together as a 16-bit pair when needed; individually they remain 8-bit. Therefore, calling “the” temporary register 16-bit is inaccurate. Step-by-Step Solution: Identify internal temps: W and Z are 8-bit each.They are combined (WZ) to hold 16-bit addresses during certain operations (e.g., CALL/RET helpers).But there is no single monolithic 16-bit “temporary register.”Hence the blanket statement is false. Verification / Alternative check: 8085 microarchitecture documentation lists W and Z as 8-bit. The 16-bit entities are PC and SP, plus register pairs (BC, DE, HL) formed by two 8-bit registers. Why Other Options Are Wrong: True: Overstates; not a single 16-bit temp register. True only for CALL/RET: Even then, it is a pair of 8-bit temps acting together. True when paired with accumulator: Accumulator pairing is not how a temp 16-bit register is formed. Common Pitfalls: Conflating register pairs with single registers; assuming address width (16-bit) implies internal temporary register width. Final Answer: False

Question 10

In programming languages, the keyword 'break' (to exit a loop or switch immediately) is used in which of the following?

Accepted Answer

Introduction / Context: Control-flow statements vary across languages. The 'break' statement is widely associated with C and its derivatives (C++, Java, JavaScript) to terminate loops or switch-case blocks immediately. Identifying its origin helps map concepts across languages. Given Data / Assumptions: Fortran 77: uses DO loops and arithmetic IF/GO TO; no 'break' keyword. Pascal: uses 'exit' or structured control like 'while', 'repeat-until'; classical Pascal lacks a 'break' keyword. C language: defines 'break' for loops and switch. Concept / Approach: We match the exact keyword and semantics. 'break' in C exits the nearest enclosing loop or switch. Other languages may have similar capabilities but different keywords or idioms (e.g., Fortran’s EXIT appears in later standards, not Fortran 77). Step-by-Step Solution: Check each language's standard keywords.Fortran 77: no 'break'; structured exits evolved later.Pascal (classic): no 'break'; alternatives exist.C: includes 'break' explicitly for loop/switch control.Therefore, the correct choice is C. Verification / Alternative check: C references (K&R) and modern C standards document 'break' clearly, including behavior in nested structures. Why Other Options Are Wrong: Fortran 77 and Pascal: different control constructs; lack the exact 'break' keyword in classic forms. none of the above/COBOL: do not match the described C keyword and semantics. Common Pitfalls: Assuming modern Fortran's EXIT or Pascal dialect extensions equate to classic 'break' keyword; the question targets the standard historic keyword usage. Final Answer: C

Question 11

In C/C++ style notation, which of the following is NOT an integer constant?

Accepted Answer

Introduction / Context: Literals (constants) in programming languages are categorized by type—integer, floating-point, character, string, etc. Being able to recognize integer vs. floating-point constants is foundational for understanding type rules and compiler behavior. Given Data / Assumptions: We use conventional C/C++ syntax for numeric literals. Leading sign (+ or −) is treated as a unary operator applied to a literal. Presence of a decimal point indicates a floating-point literal unless otherwise suffixed. Concept / Approach: An integer constant contains only digits (optionally with base prefixes/suffixes) and no decimal point. A floating-point constant contains a decimal point and/or exponent part with a fractional component. Thus, any literal with a decimal point like '-8.1' is not an integer constant. Step-by-Step Solution: Check each option for a decimal point.'0', '-8', '+1074', '42' → all are integers (sign is not part of the literal token in some compilers, but value is integer).'-8.1' contains a decimal point → floating-point literal.Therefore, the non-integer constant is '-8.1'. Verification / Alternative check: Compiling small snippets confirms types via typeof or format specifiers (e.g., printf with %d vs. %f). Why Other Options Are Wrong: 0, −8, +1074, 42: valid integer constants in typical languages. Common Pitfalls: Treating a leading '+' as invalid—most languages accept it; confusing a minus sign with part of the literal vs. unary negation (type remains integer). Final Answer: -8.1

Question 12

8085/ALU flags: “Z (Zero) flag is reset if an ALU operation results in 0.” Determine whether the statement is correct.

Accepted Answer

Introduction / Context: Processor status flags reflect the outcome of arithmetic/logic operations. The Zero (Z) flag indicates whether the result of an operation is numerically zero. Misinterpreting set/reset polarity leads to incorrect branching and condition checks in assembly programs. Given Data / Assumptions: 8085 (and many CPUs) define Z = 1 (set) when the result equals zero. Z = 0 (reset) when the result is non-zero. Applies across arithmetic and logical ALU operations that update flags. Concept / Approach: The statement claims the opposite of the specification. Correct behavior: if the result is 0, the Zero flag is set; if the result is not 0, the Zero flag is reset. This allows instructions like JZ/JNZ (jump if zero / not zero) to test equality efficiently. Step-by-Step Solution: Consider an operation yielding 0 (e.g., SUB A from itself).CPU sets Z = 1 to indicate a zero result.Therefore, the claim “Z is reset if result is 0” is incorrect.Hence, the correct evaluation is: False. Verification / Alternative check: Consult 8085 instruction set summaries: after ANA, ORA, XRA, ADD/SUB etc., the Zero flag is set when the result equals 00h, and cleared otherwise. Why Other Options Are Wrong: True / conditional variants: contradict standard 8085 flag definitions. Depends on carry: Zero flag is independent of carry; they are separate bits. Common Pitfalls: Reversing the meaning of “set” and “reset”; assuming only arithmetic updates Zero—logical ops also update it. Final Answer: False

Question 13

Assertion–Reason (8085 Microprocessor): The 8085 has an on-chip oscillator with an inbuilt crystal; therefore, a crystal oscillator is preferred for frequency stability.

Accepted Answer

Introduction / Context: This assertion–reason item tests factual knowledge of the Intel 8085 microprocessor clocking scheme and the general principle of using crystal oscillators for frequency stability in digital systems and microcontrollers. Given Data / Assumptions: Assertion (A): 8085 has an on-chip oscillator with an inbuilt crystal. Reason (R): Crystal oscillators are preferred for frequency stability. Understanding of 8085 clock pins X1 and X2 and the need for an external timing element. Concept / Approach: The Intel 8085 includes an on-chip clock generator/amplifier stage that requires an external crystal, ceramic resonator, or LC network connected to pins X1 and X2. The 8085 does not contain an 'inbuilt crystal' inside the chip package. Separately, it is a well-established fact that crystal oscillators provide superior frequency stability compared to RC oscillators, hence are generally preferred where timing accuracy matters. Step-by-Step Solution: Identify the claim in A: 'inbuilt crystal' inside 8085 – this is incorrect; the crystal is external.Confirm R: crystal oscillators are indeed used for stable frequency references – this is correct.Match to assertion–reason options: A is false, R is true – the correct choice is 'A is wrong R is correct'. Verification / Alternative check: Datasheets and standard texts show 8085 requires an external crystal (typically 6.144 MHz or similar) at X1/X2. The internal stage merely sustains oscillation; it does not house the crystal element. Why Other Options Are Wrong: Options claiming A true contradict the need for an external crystal.'Both wrong' is incorrect because R is a valid general statement about oscillator stability. Common Pitfalls: Confusing 'on-chip oscillator driver' with an 'on-chip crystal'; only the driver is on chip. Final Answer: A is wrong R is correct

Question 14

C language literals: Identify the one real (floating) constant that is not valid in C scientific notation.

Accepted Answer

Introduction / Context: This question checks the rules for writing floating-point constants in C using scientific notation (exponent form). The exponent part must be an integer (no decimal point), and there must be no spaces within the literal. Given Data / Assumptions: C real constants may use the format: [digits][.digits][(E|e)[+|-]digits]. Exponent 'digits' must be an integer (base-10), not a floating number. Case E/e is allowed; optional sign on exponent is allowed. Concept / Approach: We compare each candidate with the lexical rules for C floating constants. Any deviation (for example, a non-integer exponent like '2.0') makes the token invalid. All valid forms must have an exponent consisting solely of optional sign followed by one or more decimal digits. Step-by-Step Solution: Check option a: '1.2e2.0' → exponent '2.0' is not an integer; invalid.Option b: '-2.3e-2' → valid (exponent is −2).Option c: '-2.3E2' → valid (uppercase E allowed; exponent 2).Option d: '-2.3e2' → valid (exponent 2).Option e: '3.0E+0' → valid (exponent +0). Verification / Alternative check: The C standard grammar for floating constants requires the exponent part to be an optionally signed sequence of digits; a decimal point in the exponent is illegal. Why Other Options Are Wrong: All others use an integer exponent and follow the allowed forms, so they are valid literals in C. Common Pitfalls: Including spaces or decimal points inside the exponent; inserting a space splits tokens and makes them invalid. Final Answer: 1.2e2.0

Question 15

Assertion–Reason (Instruction Length in 8085): Making source and destination addresses implicit reduces instruction length; this is because the 8085 has only three addressing modes.

Accepted Answer

Introduction / Context: Instruction encoding length depends heavily on addressing modes. If operands (source/destination) are implied, fewer bits are required, resulting in shorter opcodes—important in 8-bit CPUs like the 8085. Given Data / Assumptions: Assertion: Implicit addressing reduces instruction length. Reason: 8085 supposedly has only 3 addressing modes. Real addressing modes of 8085 include immediate, register, direct, register indirect, and implied (among others like RST). Concept / Approach: Implicit (implied) addressing hard-codes the operand/register in the instruction definition, eliminating the need to encode register fields or addresses. This indeed reduces the number of bits. However, the stated reason is factually incorrect because the 8085 supports more than three addressing modes. Step-by-Step Solution: Confirm A: Implied addressing → shorter opcodes; true.Check R: 'only three addressing modes' → false; 8085 commonly recognized with ≥5 (immediate, register, direct, register-indirect, implied).Conclusion: A true, R false → select 'A is correct R is wrong'. Verification / Alternative check: Look up any 8085 programming manual and count distinct addressing styles used by instructions like MVI (immediate), MOV (register), LXI (immediate 16-bit), STA/LDA (direct), and instructions such as CMA (implied). Why Other Options Are Wrong: Any option implying R is correct misrepresents 8085 addressing modes. Common Pitfalls: Confusing the number of addressing modes with the number of bytes in an instruction; they are related but not identical. Final Answer: A is correct R is wrong

Question 16

8085 bit-rotation as multiplication: Using the RAL (Rotate Accumulator Left through Carry) instruction, how many RAL operations are needed to multiply an 8-bit unsigned value by 8?

Accepted Answer

Introduction / Context: Left shifts on binary integers multiply by powers of two. On the 8085, arithmetic left shift is not a single instruction, but RAL (rotate left through carry) effectively shifts left by one bit when used carefully, enabling multiplication by 2^n. Given Data / Assumptions: Instruction RAL rotates the accumulator left through the carry flag by 1 bit. We are multiplying an unsigned value by 8 (which is 2^3). Overflow and carry handling are the programmer’s responsibility. Concept / Approach: Each left shift by one bit multiplies the binary number by 2. Therefore, to multiply by 8, we need three successive left shifts. On 8085, three RAL operations can be used in sequence to achieve this, provided we account for carry if needed. Step-by-Step Solution: Target factor: 8 = 2^3.One RAL ≈ one left shift → multiply by 2.Three RAL instructions → multiply by 2^3 = 8. Verification / Alternative check: Test with a small value, e.g., A=0000 0011 (3). After three RALs (ignoring overflow), we get 0001 1000 (24) which is 3*8. Why Other Options Are Wrong: Once or twice: gives 2x or 4x, not 8x.Four times: gives 16x, not 8x. Common Pitfalls: Forgetting that RAL rotates through carry; if high bits spill into carry, you must decide how to handle overflow. Final Answer: thrice

Question 17

Pascal numeric operations with TRUNC: Given X := 2.57; then X := (X + 0.06) * 10; I := TRUNC(X); X := I; X := X / 10.0; what is the final value of X?

Accepted Answer

Introduction / Context: This problem exercises understanding of floating operations, truncation to integer, and reassignment in Pascal. TRUNC removes the fractional part (toward zero), which affects subsequent computations when we convert back to real and rescale. Given Data / Assumptions: Initial X = 2.57 (real). Operations: add 0.06, scale by 10, TRUNC to integer I, assign back to X, then divide by 10.0. TRUNC(x) discards the fractional part, e.g., TRUNC(26.3) = 26. Concept / Approach: Follow the sequence carefully; TRUNC changes 26.3 to 26, and subsequent division by 10.0 yields 2.6, not the pre-TRUNC value. This is a classic rounding vs truncation illustration. Step-by-Step Solution: Start: X = 2.57.Compute (X + 0.06) * 10 = (2.57 + 0.06) * 10 = 2.63 * 10 = 26.3.I := TRUNC(26.3) = 26.X := I → X = 26.X := X / 10.0 → 26 / 10.0 = 2.6. Verification / Alternative check: If instead of TRUNC we had used ROUND, the result could become 2.6 or 2.63 depending on rounding behavior; here TRUNC explicitly removes the fractional part, confirming 2.6. Why Other Options Are Wrong: 2 or 26.3 ignore the subsequent steps.2.63 would be true before TRUNC and reassignment; it is not the final value.2.57 is the initial value only. Common Pitfalls: Confusing TRUNC with ROUND; forgetting reassignment X := I before dividing by 10.0. Final Answer: 2.6

Question 18

EEPROM capabilities: Which set of operations is supported by a typical byte-erasable EEPROM device?

Accepted Answer

Introduction / Context: Nonvolatile memories differ in their erase/write granularity. EEPROMs (Electrically Erasable Programmable ROMs) allow erasing and writing at the byte level, unlike UV-EPROMs (chip erase with UV light) or many NOR/NAND flash memories (block or sector erase). Given Data / Assumptions: Device: classic EEPROM (not flash). Granularity: byte erase and byte write are supported. Chip-erase is generally a flash feature, not standard for byte-addressable EEPROM. Concept / Approach: Match the definition: EEPROM supports random byte write and byte erase alongside standard read operations. Therefore, options that include 'chip erase' are more indicative of EPROM (UV) or Flash devices rather than EEPROM. Step-by-Step Solution: Eliminate 'read only': incorrect, EEPROMs are writable.Confirm EEPROM byte-level erase/write: supported.'Chip erase' not typical for byte-erasable EEPROM → discard options claiming chip erase. Verification / Alternative check: Consult datasheets for 24xx/28xx series EEPROMs: specify byte write/erase cycles and endurance, not chip-wide erase requirements. Why Other Options Are Wrong: 'Read only' contradicts EEPROM definition.Including 'chip erase' conflates EEPROM with flash/EPROM behaviors. Common Pitfalls: Assuming all nonvolatile memories behave like flash; EEPROM's key benefit is fine granularity. Final Answer: read, byte erase and byte write operations

Question 19

Pascal modulo with negative divisor: If A = 20 and B = -7 in Pascal, what is the value of A mod B?

Accepted Answer

Introduction / Context: Different languages define integer division and modulo differently for negative operands. Pascal defines mod via the identity a = (a div b) * b + (a mod b), with div truncating toward zero in standard Pascal implementations. Given Data / Assumptions: A = 20, B = -7. Pascal's div truncates toward zero (implementation-typical). a mod b = a − b * (a div b). Concept / Approach: Compute a div b first, then use the defining identity to find a mod b. With truncation toward zero, 20 div −7 = −2 (since −2.857… truncated toward zero is −2). Plugging into the mod identity gives the remainder. Step-by-Step Solution: Compute q = 20 div (−7) = −2.Compute r = 20 − (−7) * (−2) = 20 − 14 = 6.Therefore, 20 mod (−7) = 6. Verification / Alternative check: Check identity: (−2) * (−7) + 6 = 14 + 6 = 20. The remainder's magnitude is less than |b| = 7, which is consistent. Why Other Options Are Wrong: 2, 3: do not satisfy the identity with the correct truncation behavior.−1: remainder should keep magnitude less than |b| and satisfy the equality; −1 fails with q = −2. Common Pitfalls: Assuming Python-style floor division or C's implementation specifics; languages differ in div/mod rules with negatives. Final Answer: 6

Question 20

EPROM pin count reasoning: A 256 × 4 EPROM provides 256 addresses of 4 data bits each. How many address and data pins does it have?

Accepted Answer

Introduction / Context: Memory device pin counts follow directly from the required address space and data width. This problem reinforces binary addressing calculations for ROM/EPROM devices. Given Data / Assumptions: Organization: 256 × 4 (256 locations, each 4 bits wide). Binary addressing: number of address pins equals log2(number of addresses). Data width dictates the number of data pins. Concept / Approach: Since 256 = 2^8, we need 8 address lines (A0…A7) to uniquely select a word. The data width is 4 bits, so we need 4 data pins (D0…D3) to read out a nibble from the selected location. Step-by-Step Solution: Compute address pins: log2(256) = 8 → 8 address pins.Data width: 4 bits → 4 data pins.Therefore, pin configuration is 8 address and 4 data pins (ignoring control pins like CE/OE/VPP). Verification / Alternative check: Cross-check with standard memory organizations: 1K × 8 uses 10 address pins; 256 × 4 is smaller, so 8 address pins is consistent. Why Other Options Are Wrong: Options with 4 address pins imply only 16 addresses (2^4), far less than 256.8 data pins would imply 8-bit width, not 4 bits. Common Pitfalls: Confusing total bits (256×4=1024 bits) with address pin count; address pins depend only on the number of addresses. Final Answer: 8 address pins and 4 data pins

Microprocessors Questions