JKSSB Core Computer Science MCQs

Explanation

Statements I and II are true and represent standard state transitions. Statement III is false because a process cannot go directly from 'Waiting' to 'Running'. Once the I/O is complete, it must first be moved to the 'Ready' queue to wait its turn for the CPU to be allocated by the scheduler

Explanation

Thrashing happens when the working set of a process is not currently in memory, causing continuous page faults and disk I/O. This severely degrades system performance because the CPU spends its time swapping pages in and out rather than executing instructions.

Explanation

Multiply the fraction by 2 iteratively and collect the integer parts from top to bottom:

0.625 * 2 = 1.25 (integer part 1)

0.25 * 2 = 0.50 (integer part 0)

0.50 * 2 = 1.00 (integer part 1)

Reading the integers from top to bottom gives 0.101.

Explanation

Segmentation divides memory into variable-sized chunks based on the logical divisions of a program. Over time, as segments are loaded and removed, it leaves small, unusable holes of memory scattered around, causing external fragmentation. Paging, on the other hand, uses fixed-size blocks and suffers from internal fragmentation.

Explanation

Deadlock Prevention (A) pairs with (2) because it strictly constraints how requests can be made to invalidate conditions like "Hold and Wait" or "Circular Wait" from the very beginning.

Deadlock Avoidance (B) pairs with (3) because it requires the OS to look at future resource needs and dynamically calculate if granting a request keeps the system in a safe state.

Deadlock Detection (C) pairs with (4) because it does not stop deadlocks from happening; instead, it periodically runs an algorithm to find cycles and then kills processes or preempts resources to recover.

Circular Wait (D) pairs with (1) as it is the exact definition of the 4th necessary Coffman condition for a deadlock to occur.

Explanation

Statements 1 and 2 are correct. Statement 3 is the exact opposite of the condition. "No Preemption" means that a resource cannot be forcibly taken away by the OS; it can only be released voluntarily by the process holding it after that process has completed its task.

Explanation

Paging (A) pairs with (3) because its defining characteristic is breaking logical memory into fixed-size blocks (pages) to fit into physical frames, removing the need for contiguous allocation.

Segmentation (B) pairs with (1) because it divides memory based on the logical structure of the program (like functions and arrays), which results in variable-sized blocks.

Compaction (C) pairs with (4) as it is the process of physically moving active processes in memory to consolidate all free space into one large, usable block.

Thrashing (D) pairs with (2) as it defines the scenario where high page fault rates cause the OS to constantly read/write to the disk, halting actual CPU progress.

Explanation

Set up the equation using positional notation with an unknown base b: (4b + 1) - (2b + 2) = (1b + 5). Simplifying this gives 2b - 1 = b + 5, which solves mathematically to b = 6.

Explanation

Statements 1 and 2 are correct descriptions of how overflow acts and is detected by hardware (via an XOR gate on the carries). Statement 3 is incorrect. In 2's complement math, a carry out of the MSB is perfectly normal and is usually just discarded. For example, adding -1 (1111 1111) and -1 (1111 1111) yields 1 1111 1110. The carry out is discarded, leaving 1111 1110 (-2), which is a valid, correct result with no overflow.

Explanation

Statements 1 and 2 are correct. Overflow is a capacity issue, and when adding numbers of the same sign, the result might exceed the storage capacity. Statement 3 is incorrect. When adding numbers with opposite signs (one positive, one negative), the magnitude of the result will always be smaller than the larger of the two operands. Therefore, overflow is mathematically impossible when adding numbers of opposite signs.

Explanation

Statements 1 and 3 are correct. Grouping by 3 bits translates directly to base-8, and two hex digits (4 bits each) make an 8-bit byte. Statement 2 is incorrect. In hexadecimal, counting from 10 starts at A. Therefore, 10=A, 11=B, 12=C, 13=D, 14=E, and 15=F.

Explanation

Statements 1 and 3 are correct. BCD translates digits one by one (e.g., 45 becomes 0100 0101), and Gray code minimizes hardware transition errors by changing only one bit at a time. Statement 2 is incorrect because Gray code is an unweighted code; the positions of its bits do not hold inherent place values.

Background:

The Systems

Binary (Standard): The native language of computers. It converts a whole decimal number into a single sequence of 0s and 1s based on powers of 2 (1, 2, 4, 8, etc.).

Example: The decimal number 15 is 1111 in binary.

BCD (Binary-Coded Decimal): A system that translates each individual digit of a decimal number into its own 4-bit binary chunk, rather than converting the whole number at once.

Example: For the decimal 15, the '1' becomes 0001 and the '5' becomes 0101. So, 15 in BCD is 0001 0101. It is easier for humans to read but takes up more computer memory.

Gray Code: A special binary sequence where only one single bit changes when you go from one number to the next. In normal binary, going from 3 (011) to 4 (100) flips three bits at once, which can cause reading errors in physical hardware sensors. Gray code prevents this.

2. Conversions (Binary and Gray)

To convert between the two, you use a logic rule called XOR (Exclusive OR). In simple terms:

If you compare two bits and they are the SAME (0 and 0, or 1 and 1), the result is 0.

If you compare two bits and they are DIFFERENT (1 and 0, or 0 and 1), the result is 1.

How to Convert Binary to Gray Code

Bring down the first bit: The leftmost bit (Most Significant Bit) of your Gray code is exactly the same as the first bit of your Binary number.

Compare neighbors: To find the next Gray bit, look at the Binary number. Compare the current Binary bit with the Binary bit immediately to its left.

Apply the rule: Same = 0, Different = 1. Repeat this down the line.

Example: Convert Binary 1010 to Gray

1st bit: Bring down the 1. (Gray starts with 1)

2nd bit: Compare Binary bits 1 and 2 (1 and 0). They are different, so write 1.

3rd bit: Compare Binary bits 2 and 3 (0 and 1). They are different, so write 1.

4th bit: Compare Binary bits 3 and 4 (1 and 0). They are different, so write 1.

Result: Binary 1010 = Gray 1111.

How to Convert Gray Code to Binary

Bring down the first bit: The leftmost bit of your Binary number is exactly the same as the first bit of your Gray code.

Compare diagonally: To find the next Binary bit, compare the current Gray bit with the Binary bit you just calculated.

Apply the rule: Same = 0, Different = 1. Repeat this down the line.

Example: Convert Gray 1111 to Binary

1st bit: Bring down the 1. (Binary starts with 1)

2nd bit: Compare the next Gray bit (1) with the Binary bit you just wrote (1). They are the same, so write 0.

3rd bit: Compare the next Gray bit (1) with the newest Binary bit (0). They are different, so write 1.

4th bit: Compare the next Gray bit (1) with the newest Binary bit (1). They are the same, so write 0.

Result: Gray 1111 = Binary 1010.

Explanation

Statements 1 and 2 are correct definitions of the complement operations. Statement 3 is incorrect. In an 8-bit 2's complement system, 1111 1111 represents the decimal number -1. The value -128 is represented by 1000 0000.

BACKGROUND:

Here we talk about Signed binary numbers. In unsigned binary number all bits represent value but in signed binary numbers leftmost number represent sign.

In 8-bit, the leftmost bit determines the sign (0 for positive, 1 for negative), and the remaining 7 bits hold the value.

In 8-bit, the leftmost bit determines the sign (0 for positive, 1 for negative), and the remaining 7 bits hold the value.

1. Sign-Magnitude (Normal Binary)

It works just like adding a + or - sign in front of a number.

Positives: Start with 0. (e.g., +5 is 00000101)

Negatives: Start with 1. The rest stays the same. (e.g., -5 is 10000101)

The Problem: Has two zeroes (00000000 for +0 and 10000000 for -0).

8-bit Range: -127 to +127.

2. 1's Complement

Negatives are made by simply flipping every single bit of the positive number (0 becomes 1, 1 becomes 0).

Positives: Same as normal binary. (+5 is 00000101)

Negatives: Flip all bits of +5. (-5 is 11111010)

The Problem: Still has two zeroes (00000000 for +0 and 11111111 for -0).

8-bit Range: -127 to +127.

3. 2's Complement (The Modern Standard)

Negatives are made by flipping all bits and then adding 1. This fixes the double-zero problem and is what modern computers use.

Positives: Same as normal binary. (+5 is 00000101)

Negatives: Flip all bits of +5 (11111010), then add 1. (-5 is 11111011)

The Benefit: Only one zero (00000000). Because we lose "-0", we gain an extra negative number.

8-bit Range: -128 to +127.

The range of numbers that can be represented by the above number Systems can be represented by following

Sign-Magnitude: -(2^{n-1} - 1) to +(2^{n-1} - 1)

1's Complement: -(2^{n-1} - 1) to +(2^{n-1} - 1)

2's Complement: -2^{n-1} to +(2^{n-1} - 1)