Question 1

Java compound assignment operator: If x = 5 and y = 2, what is the value of x after executing x += y?

Accepted Answer

Introduction / Context:Compound assignment operators in Java (like +=) combine an arithmetic operation with an assignment, improving code brevity while preserving type rules and evaluation order.Given Data / Assumptions:Initial values: x = 5, y = 2 (integers).Statement: x += y which is equivalent to x = x + y.Concept / Approach:Evaluate x + y first, then store the result back into x. Since both x and y are ints, there is no implicit narrowing issue in this case.Step-by-Step Solution:Compute x + y = 5 + 2 = 7.Assign back: x = 7.Therefore, the result is 'x = 7'.Verification / Alternative check:In Java, x += y is exactly equivalent to x = (type of x)(x + y); with both ints, this is the same as plain addition then assignment.Why Other Options Are Wrong:x = 2, x = 3, x = 5, x = 10 do not reflect the addition and assignment correctly.Common Pitfalls:Misunderstanding compound assignment with mixed types (e.g., byte), where implicit cast occurs. Not relevant here but good to remember.Final Answer:x = 7

Question 2

C 16-bit integer constants: Which of the following is not a valid 16-bit integer constant value in C (assuming a 16-bit int range of −32768 to +32767)?

Accepted Answer

Introduction / Context:This tests knowledge of integer literal ranges for a 16-bit int. While modern systems typically use 32-bit int, many exam questions still assume a 16-bit range for portability and historical reasons.Given Data / Assumptions:Assumed 16-bit signed int range: −32768 to +32767.We examine each literal to see whether it lies within the permitted range.Concept / Approach:Any literal outside the stated range is invalid for assignment to a 16-bit int without causing overflow or requiring a larger integer type. The syntax of the constants is otherwise standard (leading + or − sign allowed).Step-by-Step Solution:321, −162, +1, and 0 are clearly within −32768…+32767.−65321 is much less than −32768; it is out of range for a 16-bit int.Hence, −65321 is not a valid 16-bit integer constant under the assumption.Verification / Alternative check:Consider storage width: 16-bit two’s complement cannot encode magnitude 65321; wrap-around would occur if forced, which is undefined/implementation-specific in literal typing context.Why Other Options Are Wrong:All other values fall within the representable range and thus are valid.Common Pitfalls:Forgetting that the negative bound (−32768) has magnitude one larger than the positive bound (+32767) in two’s complement.Final Answer:-65321

Question 3

In the C programming language, which of the following identifiers cannot be used as a variable name (choose the reserved keyword that is invalid as an identifier)?

Accepted Answer

Introduction:In C programming, identifiers (variable, function, and type names) must follow strict lexical rules. A common beginner trap is attempting to use a reserved keyword as a variable name. This question checks understanding of C's identifier syntax and the reserved keyword set.Given Data / Assumptions:Language context: ANSI C / ISO C.Candidate names: else, coal, ram, vendy.Goal: identify the invalid variable name according to C rules.Concept / Approach:C identifiers must start with a letter or underscore and then may contain letters, digits, or underscores. However, no identifier may be a reserved keyword. Keywords have fixed meanings to the compiler and cannot be redefined as variable names. The token 'else' is a control-flow keyword paired with 'if' and 'else if' constructs, so it cannot be repurposed as an identifier.Step-by-Step Solution:Step 1: List the options and quickly check character legality (letters only) — all pass this basic test.Step 2: Compare each token against the C keyword list (auto, break, case, char, const, continue, default, do, double, else, enum, extern, float, for, goto, if, inline (C99), int, long, register, restrict (C99), return, short, signed, sizeof, static, struct, switch, typedef, union, unsigned, void, volatile, while, _Bool, _Complex, _Imaginary (C99)).Step 3: Recognize 'else' appears in the keyword set and is therefore invalid as a variable name.Step 4: Confirm that 'coal', 'ram', and 'vendy' are not keywords and follow identifier rules, so they are valid.Verification / Alternative check:Compilers will emit a syntax error if you attempt int else = 5; because the parser expects the keyword 'else' to follow an 'if' statement, not to declare an object.Why Other Options Are Wrong:'coal' – not a keyword; valid identifier.'ram' – not a keyword; valid identifier (despite being a common acronym).'vendy' – not a keyword; valid identifier.Common Pitfalls:Confusing natural-language words with keywords; assuming case-insensitive matching (C is case-sensitive; 'Else' would be valid, though discouraged). Avoid shadowing and pick descriptive names even when valid.Final Answer:else

Question 4

In Java, which of the following array declarations are possible: (1) an array of integers, (2) an array of String objects, (3) a multidimensional array (array of arrays), (4) a single array mixing integers and Strings?

Accepted Answer

Introduction:This question tests understanding of Java array typing rules: homogeneity, object arrays, and multidimensional arrays. Knowing what is and is not type-safe in Java is essential for avoiding ClassCastException and compile-time errors.Given Data / Assumptions:Statements under consideration: 1 (int[]), 2 (String[]), 3 (e.g., int[][]), 4 (one array mixing ints and Strings).Java is statically typed; array element types are fixed at creation.Concept / Approach:Java arrays are homogeneous: every element has the same declared type. int[] holds primitives of type int only; String[] holds references to String objects only. Multidimensional arrays (like int[][] or String[][]) are fully supported. A single array mixing primitives and reference types (e.g., ints and Strings) is not allowed. An Object[] could hold both, but then integers would be boxed as Integer and the statement specifically says an array of integers and Strings together, which is not a single strongly typed array of those two distinct types.Step-by-Step Solution:Step 1: Evaluate (1): int[] is valid in Java.Step 2: Evaluate (2): String[] is valid in Java.Step 3: Evaluate (3): Multidimensional arrays (e.g., int[][]) are valid.Step 4: Evaluate (4): A single array mixing ints and Strings is not valid as a Java array type; Java requires a single element type.Verification / Alternative check:You can compile small snippets: int[] a = {1, 2}; String[] s = {"a", "b"}; int[][] m = {{1,2},{3,4}}; // all OKObject[] mix = {1, "x"}; // compiles, but this is not an 'array of integers and strings'; it is an Object[] with boxingWhy Other Options Are Wrong:'All' – wrong because (4) is invalid. '1 and 2 only' – ignores valid multidimensional arrays. '1, 3 and 4 only' – includes invalid (4) and excludes (2).Common Pitfalls:Confusing Object[] (heterogeneous) with a typed array; forgetting autoboxing implications; mixing primitives and references in a single typed array.Final Answer:1, 2 and 3 only

Question 5

Given JCOKE = 98 and LPEPSI = 42, evaluate the Fortran-style arithmetic IF: IF (JCOKE - 3 * LPEPSI) 5, 6, 7 with labels 5: JCOKE = JCOKE + 5, 6: JCOKE = JCOKE + 8, 7: JCOKE = JCOKE + 11. What is the final value of JCOKE?

Accepted Answer

Introduction:This problem checks knowledge of the classic Fortran arithmetic IF statement and evaluates control flow based on the sign of an expression. Understanding how labels are chosen for negative, zero, or positive results is the key concept.Given Data / Assumptions:JCOKE = 98LPEPSI = 42Statement: IF (JCOKE - 3 * LPEPSI) 5, 6, 7Label actions: 5: JCOKE = JCOKE + 5; 6: JCOKE = JCOKE + 8; 7: JCOKE = JCOKE + 11Concept / Approach:In Fortran's arithmetic IF, the control transfers to the first label if the expression is negative, to the second label if the expression is zero, and to the third label if the expression is positive. So we compute the expression and then select the corresponding label to update JCOKE.Step-by-Step Solution:Step 1: Compute the expression value: JCOKE - 3 * LPEPSI = 98 - 3 * 42.Step 2: Evaluate the multiplication first: 3 * 42 = 126.Step 3: Subtract: 98 - 126 = -28.Step 4: Since the result -28 is negative, branch to label 5.Step 5: Apply label 5: JCOKE = JCOKE + 5 = 98 + 5 = 103.Verification / Alternative check:Check other branches to ensure they do not apply: zero would go to label 6, positive to label 7. Because -28 is negative, label 5 is uniquely correct.Why Other Options Are Wrong:106 – corresponds to label 6 (zero case), not applicable. 109 – corresponds to label 7 (positive case), not applicable. 'none of the above' – incorrect because 103 matches label 5.Common Pitfalls:Misremembering arithmetic IF semantics; performing operations in the wrong order; treating arithmetic IF as logical IF.Final Answer:103

Question 6

When selecting an integrated memory chip for a digital system, which characteristics should be examined before purchase and design-in?

Accepted Answer

Introduction:Practical hardware selection requires understanding not only how much memory you need, but also the electrical and timing behavior that ensures reliable operation on a bus or controller. This question checks awareness of data-sheet driven selection criteria.Given Data / Assumptions:We are choosing a memory IC (e.g., SRAM, DRAM, Flash).Options include capacity, AC characteristics, and DC characteristics.Goal: identify whether one, some, or all properties must be considered.Concept / Approach:Capacity determines address space coverage. DC characteristics specify voltage levels, static currents, leakage, and input/output thresholds that determine logic compatibility and power budgeting. AC characteristics specify setup/hold times, access latency, clock-to-output delays, and timing margins essential for meeting bus frequency targets. All three are necessary to guarantee functional and reliable integration.Step-by-Step Solution:Step 1: Check required storage: capacity must meet system needs and addressing scheme.Step 2: Check DC specs: ensure operating voltage, input high/low, output drive, and worst-case currents match the power and logic families.Step 3: Check AC specs: ensure read/write cycle times, setup/hold, and access times meet clock rate and controller timings with margin.Verification / Alternative check:Cross-verify with controller timing diagrams and use derating across temperature/voltage corners to ensure robustness.Why Other Options Are Wrong:Choosing only capacity ignores whether the device can electrically and temporally interface correctly. Selecting only AC or only DC omits the other half of the reliability equation.Common Pitfalls:Overlooking worst-case timing; ignoring I/O drive limits; not checking standby currents that affect battery life.Final Answer:all of the above

Question 7

In standard Pascal, consider the following statements about files: (1) A file is a data structure consisting of a sequence of components of the same type. (2) The number of components in a file is variable. (3) Components can be accessed only sequen…

Accepted Answer

Introduction:This question examines Pascal's file model, especially how typed and text files are viewed conceptually. It differentiates core language properties from implementation-specific extensions like random access on typed files in some compilers.Given Data / Assumptions:Statement 1: Homogeneous sequence of components.Statement 2: File length can vary.Statement 3: Access is only sequential from the beginning.Assume standard Pascal semantics (not Turbo-specific extensions).Concept / Approach:In standard Pascal, files are sequences of elements (typed files: 'file of T') or characters/lines (text files). They are homogeneous (all components same type). File length may change with writing/appending. Although many practical implementations permit Seek for typed files, the standard conceptual model emphasizes sequential processing. Therefore, statements (1) and (2) are universally correct, while (3) is not strictly true across implementations and use-cases.Step-by-Step Solution:Step 1: Validate homogeneity: 'file of integer' contains only integers — confirms (1).Step 2: Validate variability: appending or truncating can change the number of components — confirms (2).Step 3: Evaluate access mode: while text files are typically sequential, typed files may support position-based access via Seek in many compilers — weakens universal truth of (3).Verification / Alternative check:Check language references: conceptual definition emphasizes sequence and homogeneity; random access is compiler/RTL dependent, not guaranteed by the pure standard.Why Other Options Are Wrong:'All' – overstates (3). '2 and 3 only' – includes (3) incorrectly. '1 and 3 only' – includes (3) incorrectly.Common Pitfalls:Assuming Turbo Pascal capabilities are universal; conflating text-file sequential constraints with typed-file possibilities.Final Answer:1 and 2 only

Question 8

In computer architecture, are instructions, data, and intermediate/final results during processing held in the Arithmetic Logic Unit (ALU)?

Accepted Answer

Introduction:This concept question distinguishes the roles of core CPU components: the Arithmetic Logic Unit (ALU), registers, cache, and main memory. It checks whether learners know that storage and computation are distinct responsibilities.Given Data / Assumptions:Statement claims ALU 'holds' instructions, data, and results during processing.Context: von Neumann architecture with typical CPU organization.Concept / Approach:The ALU performs arithmetic and logical operations. It does not serve as a storage repository. Instructions are fetched from memory (possibly via cache) and decoded by the control unit. Operands and results are temporarily stored in registers (e.g., accumulator, general-purpose registers) and caches; long-term storage is in main memory or secondary storage. The ALU interacts with registers (source/destination) under control signals but does not 'hold' data persistently.Step-by-Step Solution:Step 1: Identify ALU function: execute add, subtract, and, or, shift, compare.Step 2: Identify storage points: registers and memory hierarchy hold instructions/data/results.Step 3: Conclude statement is false: ALU computes; it does not store.Verification / Alternative check:Microarchitecture diagrams consistently show the ALU with inputs/outputs to register files; control and storage are separate blocks.Why Other Options Are Wrong:'True' would conflate transient signal presence in the ALU's datapath with actual storage responsibility.Common Pitfalls:Thinking any unit that 'handles' data also 'stores' it; overlooking the central role of registers and cache for temporaries.Final Answer:False

Question 9

Which memory in the computer memory hierarchy provides the fastest access time in typical systems?

Accepted Answer

Introduction:Computer systems use a memory hierarchy to balance speed, capacity, and cost. This question tests recognition of which tier offers the lowest latency for the CPU.Given Data / Assumptions:Options: cache, primary (main memory/RAM), mass storage (SSD/HDD), offline backup (tape/external).Typical modern CPU with L1/L2/L3 caches.Concept / Approach:L1 cache resides closest to the CPU core and offers the smallest access latency, followed by L2, L3, then DRAM (primary memory). Mass storage devices are orders of magnitude slower, and offline backups are slower still and not directly addressable by the CPU.Step-by-Step Solution:Step 1: Order by latency: L1/L2/L3 cache Step 2: Identify the fastest among the given categories: cache.Verification / Alternative check:Microbenchmarks consistently show nanosecond-scale cache hits versus tens of nanoseconds for DRAM and micro/millisecond scales for storage.Why Other Options Are Wrong:Primary (RAM) is slower than cache. Mass storage and offline backup are much slower and not CPU-cached.Common Pitfalls:Equating higher capacity with higher speed; confusing cache with system-level disk caches.Final Answer:Cache

Question 10

In Fortran, which of the following real variable names is invalid according to identifier rules?

Accepted Answer

Introduction:Classic Fortran identifier rules restrict variable names to specific character sets and formats. This question checks recognition of illegal characters and spacing in identifiers.Given Data / Assumptions:Options: BETA, ALPHA, A, AB * 2.Context: traditional Fortran naming (letters/digits, starting with a letter).Concept / Approach:Fortran variable names must begin with a letter and may contain letters and digits (and underscores in modern Fortran). Spaces and operator symbols (*, +, -, /) are not allowed inside identifiers. Therefore any token containing spaces or arithmetic symbols is invalid as a name.Step-by-Step Solution:Step 1: Check each option for illegal characters.Step 2: 'AB * 2' contains a space, an asterisk, and a digit separated by spaces — violates identifier rules.Step 3: 'BETA', 'ALPHA', and 'A' contain only letters and are valid.Verification / Alternative check:Attempting to compile with AB * 2 as a variable name will be tokenized as identifier AB, operator *, literal 2 — a syntax error in declarations.Why Other Options Are Wrong:'BETA', 'ALPHA', and 'A' adhere to naming rules and compile successfully.Common Pitfalls:Confusing expression tokens with identifier characters; assuming spaces can be ignored inside names.Final Answer:AB * 2

Question 11

In the C programming language, which of the following is not a valid representation of a real (floating-point) constant?

Accepted Answer

Introduction:This question distinguishes integer constants from floating-point (real) constants in C. Understanding literal forms helps prevent unintended type choices and implicit conversions.Given Data / Assumptions:Options include an integer-looking token (426) and classic decimal forms with optional signs.Context: C numeric literal grammar for floating constants.Concept / Approach:In C, a floating (real) constant typically has a decimal point and/or an exponent part (e.g., 1.0, .5, 2e3, -3.14, +6.02e23). An integer constant lacks a decimal point and exponent (e.g., 426) and therefore is not a real constant. A leading plus or minus is a unary operator applied to the literal token; it does not invalidate the floating form.Step-by-Step Solution:Step 1: Inspect '321.0' — decimal point present, valid floating literal.Step 2: Inspect '-621.231' — unary minus with decimal, valid floating literal.Step 3: Inspect '+201.2314' — unary plus with decimal, valid floating literal.Step 4: Inspect '426' — no decimal point or exponent, thus an integer literal, not a real constant.Verification / Alternative check:Compilers will type '426' as an int by default, whereas literals with a decimal point are typed as double unless suffixed (e.g., f/F for float).Why Other Options Are Wrong:All other options contain a decimal point and thus are valid real constants in C.Common Pitfalls:Confusing the presence of a sign with type; forgetting exponent notation also creates real constants (e.g., 1e2).Final Answer:426

Question 12

In the C programming language, which of the following identifiers is not a valid variable name under C's identifier rules (letters, digits, and underscores only; must not start with a digit; no spaces; keywords not allowed)?

Accepted Answer

Introduction / Context:Variables in C must follow strict identifier rules to ensure the compiler can tokenize and parse code unambiguously. This question tests recognition of C identifier syntax and common invalid patterns such as starting with a digit or inserting spaces or special characters.Given Data / Assumptions:Language context: C (ANSI C/C99/C11 identifier rules).Allowed characters: letters A–Z/a–z, digits 0–9, and underscore _.First character must be a letter or underscore, not a digit.Keywords (e.g., int, float) cannot be used as identifiers.Concept / Approach:The validity of an identifier is checked against: first-character rule, allowed character set, and reserved-word avoidance. We evaluate each option against these rules and pick the only one that violates them.Step-by-Step Solution:Step 1: Check '_temp' → begins with underscore and uses only letters/underscore → valid.Step 2: Check '1alpha' → begins with digit '1' → violates first-character rule → invalid.Step 3: Check 'alpha1' → starts with a letter; digits allowed after first character → valid.Step 4: Check 'total_sum' → letters and underscore only; starts with letter → valid.Verification / Alternative check:Informal compiler mental check: if you wrote 'int 1alpha;' a compiler would emit an error at the '1' because tokens cannot begin with a digit for identifiers. The others would compile (assuming no prior conflicting declarations).Why Other Options Are Wrong:_temp: Valid because underscore is allowed as the first character.alpha1: Valid; digits are allowed after the first character.total_sum: Valid; underscores are allowed anywhere after the first position as well.Common Pitfalls:Believing digits are entirely disallowed in identifiers. They are allowed, just not as the first character.Confusing C with other languages' naming conventions; C's underscore-leading identifiers are permitted (though some names may be reserved in system headers).Final Answer:1alpha

Question 13

In the following C declarations and statements: int ram; float alpha, gamma; ram = 6400; alpha = 0.562; gamma = alpha * ram + 1; which statements are correct: (1) ram is an integer variable, (2) alpha and gamma are real (float) variables, (3) * and …

Accepted Answer

Introduction / Context:This question checks foundational C knowledge: basic data types (int, float), operators (*, +), and numeric literal classification (integer vs real/floating constants).Given Data / Assumptions:Declarations: int ram; float alpha, gamma;Assignments: ram = 6400; alpha = 0.562; gamma = alpha * ram + 1;Statements to evaluate: (1) ram is an integer variable, (2) alpha and gamma are real variables, (3) * and + are arithmetic operators, (4) 0.562 may be an integer constant or real constant.Concept / Approach:Map each statement against C rules: types from declarations, operator categories, and literal kinds. A number with a decimal point is a floating (real) constant, not an integer constant.Step-by-Step Solution:Check (1): 'int ram;' → ram has type int → statement (1) is true.Check (2): 'float alpha, gamma;' → both are float (real) → statement (2) is true.Check (3): In C, * and + are arithmetic operators (multiplication and addition) → statement (3) is true.Check (4): The literal 0.562 includes a decimal point → it is a floating (real) constant, not an integer constant → statement (4) is false.Verification / Alternative check:Compiler perspective: '0.562' tokenizes as a floating literal; integer constants have no decimal point and optional suffixes. Therefore, (4) cannot be true in C.Why Other Options Are Wrong:All: Incorrect because (4) is false.2, 3, 4 only: Incorrect because (4) is false and (1) is true.1, 2, 4 only: Incorrect because (4) is false; (3) is true.Common Pitfalls:Assuming any numeral can be either int or float; the decimal point determines a floating literal.Overlooking that 'float' variables are commonly called 'real' in older terminology.Final Answer:1, 2, 3 only

Question 14

True or False: A computer virus can hide itself on a floppy disk (diskette) but not on a hard disk drive.

Accepted Answer

Introduction / Context:This item tests conceptual understanding of what a computer virus is and where it can reside. Early viruses spread via diskettes, but storage medium restrictions are a misconception; viruses are software that can exist on many writable media and within files or boot sectors.Given Data / Assumptions:Claim: Virus can hide in a diskette but not on a hard disk.Context: General PC malware behavior, independent of specific OS versions.Concept / Approach:A virus is malicious code that attaches to hosts (executables, documents with macros, boot records). Its persistence depends on write access and execution, not on whether the medium is a diskette or a hard disk. If code can be written and executed or loaded during boot, a virus can persist there.Step-by-Step Solution:Step 1: Identify the nature of a virus → software code that replicates by infecting host files or boot sectors.Step 2: Check media properties → both diskettes and hard disks provide writable storage and boot sectors (MBR/partition boot record) in legacy systems.Step 3: Conclude → if a diskette can harbor a virus, so can a hard disk; the statement is false.Verification / Alternative check:Historical evidence: boot-sector viruses (e.g., Michelangelo era) infected hard disks and diskettes alike by modifying boot records or executable files loaded by the OS.Why Other Options Are Wrong:True: Incorrect because hard disks are just as susceptible as diskettes when malware gains write/execute paths.Common Pitfalls:Confusing infection vectors (e.g., removable media) with limitations on residency.Assuming modern protections (e.g., secure boot) apply retroactively to all contexts.Final Answer:False

Question 15

In basic computer architecture, the Instruction Cycle (IC) comprises the Fetch Cycle (FC) and the Execute Cycle (EC). Which relationship is correct?

Accepted Answer

Introduction / Context:The instruction cycle models how a CPU processes one instruction. In a simple model, it consists of fetching the instruction from memory (FC) and then executing it (EC). Some architectures add decode and memory cycles, but the canonical decomposition for fundamentals is fetch plus execute.Given Data / Assumptions:IC = instruction cycle for a single instruction.FC = fetch cycle (read the instruction from memory into the CPU).EC = execute cycle (decode/execute micro-operations to produce effects).Concept / Approach:By definition, the time or sequence for one instruction equals the time/sequence to fetch it plus the time/sequence to execute it. Therefore IC equals FC plus EC in this simplified model.Step-by-Step Solution:Identify components → instruction processing = fetch + execute.Express relationship → IC = FC + EC.Evaluate options → the only correctly formed relationship is IC = FC + EC.Verification / Alternative check:Any architecture textbook diagram for the basic cycle shows a fetch phase (PC → MAR, memory read, IR ← MDR) followed by an execute phase (ALU/Control micro-ops), summing to the whole instruction cycle.Why Other Options Are Wrong:IC = FC - EC: Nonsense dimensionally; a cycle is not a difference of sub-cycles.IC = FC + 2EC: Overcounts execute; not a standard definition.EC = IC + EC: Algebraically impossible unless IC = 0.Common Pitfalls:Confusing pipeline stages (fetch, decode, execute, memory, write-back) with the conceptual two-phase model.Assuming decode is separate; many curricula subsume decoding into execute for this definition.Final Answer:IC = FC + EC

Question 16

Convert the binary number 1101.101 to its decimal (base-10) value.

Accepted Answer

Introduction / Context:Binary-to-decimal conversion requires positional weighting. Bits left of the point use powers of 2 with nonnegative exponents; bits right of the point use negative exponents. This problem includes both integer and fractional parts, so we convert each separately and then sum.Given Data / Assumptions:Binary input: 1101.101Base: 2 (binary)Goal: Decimal valueConcept / Approach:For a binary value b3 b2 b1 b0 . b-1 b-2 b-3, the decimal value is sum(bi * 2^i). Compute integer and fractional contributions independently to avoid mistakes, then add them.Step-by-Step Solution:Integer part 1101 = 12^3 + 12^2 + 02^1 + 12^0Compute → 8 + 4 + 0 + 1 = 13Fractional part .101 = 12^-1 + 02^-2 + 12^-3Compute → 10.5 + 00.25 + 10.125 = 0.625Total decimal value = 13 + 0.625 = 13.625Verification / Alternative check:As a quick check, compare nearby options: 13.5 corresponds to .100, 13.75 corresponds to .11 (i.e., .110), and 13.875 corresponds to .111. Our fractional .101 equals 0.625, confirming 13.625.Why Other Options Are Wrong:13.5: Would require fractional part .100 (0.5), not .101.13.75: Would require .11 or .110 (0.75), not .101.13.875: Would require .111 (0.875), not .101.Common Pitfalls:Reading .101 as 0.101 in decimal; digits are binary weights.Forgetting that each right-of-point bit halves the previous weight (2^-1, 2^-2, 2^-3, ...).Final Answer:13.625

Question 17

In C programming, how many standard storage classes are there (considering classic C: auto, register, static, extern)?

Accepted Answer

Introduction / Context:Storage classes in C describe the lifetime, visibility, and storage duration of identifiers. Understanding them is essential for reasoning about scope, linkage, and performance hints to the compiler.Given Data / Assumptions:Context: Classic C (not C++ extras like mutable; and 'typedef' is a type alias specifier, not a storage class).Canonical set: auto, register, static, extern.Concept / Approach:Each storage class modifies how and where an object exists and how name resolution/linkage works across translation units.Step-by-Step Solution:auto: Default for block-scope objects; automatic storage duration; no external linkage.register: Hint that an object may be stored in a CPU register; still block scope; address-of may be restricted historically.static (at block scope): Static storage duration; preserves value across function calls; internal linkage by default at file scope if used with definitions.extern: Declares an object with external linkage defined elsewhere; does not allocate storage by itself (unless it is a tentative definition per older rules).Verification / Alternative check:Any C reference enumerates exactly these four storage classes for classic C. While modern standards refined semantics, the count remains 4 in this canonical sense.Why Other Options Are Wrong:2: Omits multiple standard classes.3: Still incomplete (missing at least one of the four).6: Overcounts by including non-storage-class specifiers or C++-only concepts.Common Pitfalls:Misclassifying typedef as a storage class (it is a declaration specifier for type aliases).Confusing C with C++ features such as mutable or thread_local in later standards.Final Answer:4

Question 18

In Fortran 77, consider the loop header: DO 52 N = 1, 10, 3. How many times will this DO loop execute?

Accepted Answer

Introduction / Context:This question checks understanding of Fortran 77 DO loop semantics: initial value, terminal value, and step (increment). Correctly counting iterations prevents off-by-one errors in numerical codes.Given Data / Assumptions:Loop header: DO 52 N = 1, 10, 3Start N0 = 1; limit NL = 10; step s = 3Concept / Approach:The loop runs with values N = N0, N0 + s, N0 + 2s, ... while N ≤ NL. Count the generated sequence elements within bounds.Step-by-Step Solution:Compute sequence: 1, 1+3 = 4, 4+3 = 7, 7+3 = 10Check bound: 10 ≤ 10 → included; next would be 13 > 10 → stopNumber of values = 4 → executions = 4Verification / Alternative check:Use count formula for inclusive arithmetic progressions: count = floor((NL - N0)/s) + 1 = floor((10 - 1)/3) + 1 = floor(3) + 1 = 4.Why Other Options Are Wrong:1: Ignores subsequent step increments.10: Mistakes limit for count.3: Misses inclusion of the terminal value 10.Common Pitfalls:Off-by-one errors when the last step lands exactly on the limit.Confusing 'step' with 'count'.Final Answer:4

Question 19

In C, which of the following is not a valid variable name (identifiers may include letters, digits, and underscores, cannot contain spaces, and must not start with a digit)?

Accepted Answer

Introduction / Context:C identifiers must follow lexical rules so the compiler can tokenize code reliably. This question targets the prohibition of whitespace inside identifiers.Given Data / Assumptions:Permitted: letters, digits, underscore.Not permitted: spaces, punctuation like commas or hyphens within an identifier.First character cannot be a digit.Concept / Approach:Test each candidate against the rules, especially whether it contains spaces. Any name with a space is not a single identifier.Step-by-Step Solution:Check 'p o t' → contains spaces → not a single token → invalid identifier.Check 'po_t' → letters and underscore only → valid.Check 'p_o_t' → letters and underscores only → valid.Check 'pot' → letters only → valid.Verification / Alternative check:Attempting to compile 'int p o t;' would be parsed as tokens 'int', 'p', 'o', 't' (three separate identifiers), producing a syntax error. The others would compile (barring redefinitions).Why Other Options Are Wrong:po_t: Allowed; underscores are valid and common.p_o_t: Allowed; multiple underscores are still valid.pot: Allowed; simple alphabetic identifier.Common Pitfalls:Assuming underscores are disallowed—C fully permits them.Confusing spaces with underscores; only underscores are legal in identifiers.Final Answer:p o t

Question 20

For the expression X = (A + B + 1.2) * (A + B - C), what is the correct left-to-right sequence of operations (operators only) considering parentheses and standard evaluation order?

Accepted Answer

Introduction / Context:Operator sequencing questions assess understanding of evaluation order with parentheses. Parentheses force inner expressions first, left-to-right where operators have the same precedence (e.g., + and -). Multiplication of the two parenthesized results occurs next, followed by assignment.Given Data / Assumptions:Expression: X = (A + B + 1.2) * (A + B - C)Operators involved: +, -, , =Parentheses dictate sub-expression evaluation before multiplication and assignment.Concept / Approach:Within each parenthesized group, perform additions/subtractions left-to-right. After both parentheses are resolved to scalar results, multiply them, then assign to X.Step-by-Step Solution:First parenthesis: compute A + B → operator '+' #1.Still inside first parenthesis: (A + B) + 1.2 → operator '+' #2.Second parenthesis: compute A + B → operator '+' #3.Still inside second parenthesis: (A + B) - C → operator '-'.Multiply the two parenthesis results → operator ''.Assign to X → operator '='.Verification / Alternative check:If you symbolically name sub-results as P = A + B + 1.2 and Q = A + B - C, then X = P * Q; sequence clearly contains two pluses for P, plus then minus for Q, then multiply, then assign.Why Other Options Are Wrong:* + + + - =: Starts with multiplication before the parentheses are resolved.+ + - * + =: Ends with '+' instead of '='; misorders multiplication and assignment.- + + + * =: Begins with '-' which does not match the first required operation.Common Pitfalls:Ignoring that + and - have equal precedence but evaluate left-to-right within parentheses.Attempting multiplication before evaluating parenthetical sums/differences.Final Answer:+ + + - * =

Microprocessors Questions

Questions

Practice smarter