Number System Practice Questions

Given $\sqrt{(224)_r} = (13)_r$, square both sides to obtain $(224)_r = (13)_r^2$.
Convert both sides to base 10: $2r^2 + 2r + 4 = (r + 3)^2$.
Expand the right side: $2r^2 + 2r + 4 = r^2 + 6r + 9$.
Rearrange into a quadratic equation: $r^2 - 4r - 5 = 0$.
Factor the equation: $(r - 5)(r + 1) = 0$, yielding solutions $r = 5$ and $r = -1$.
Since the radix must be positive and larger than the maximum digit (4), we conclude $r = 5$.

In a normalized floating-point representation, the most significant bit of the mantissa must be $1$ to ensure a unique representation. With $23$ bits reserved for the mantissa magnitude, it can be expressed as $M = 0.b_{23}b_{22}\dots b_{1} = \sum_{i=1}^{23} b_{23-i+1} 2^{-i}$.
Since the leading bit $b_{23}$ is $1$, the minimum possible magnitude is $1 \cdot 2^{-1} = 0.5$.
The maximum magnitude occurs when all $23$ bits are $1$, calculated as the geometric series $\sum_{i=1}^{23} 2^{-i} = 1 - 2^{-23}$.
Thus, the magnitude of the normalized mantissa ranges from $0.5$ to $1 - 2^{-23}$.

Booth's algorithm optimizes integer multiplication by reducing the number of addition and subtraction operations based on the number of contiguous blocks of $1$s. The algorithm performs an operation (addition or subtraction of the multiplicand) at every bit transition ($0 \to 1$ or $1 \to 0$). The pattern $101010...1010$ creates a transition at every single bit position, resulting in the maximum possible number of arithmetic operations. Conversely, patterns like $1111...1111$ or $0111...1110$ contain few transitions, allowing the algorithm to process the multiplier more efficiently. Thus, the alternating pattern forces the algorithm to execute the most steps.

The given expression can be written in powers of 16 as $3 \times 16^3 + 15 \times 16^2 + 5 \times 16^1 + 3 \times 16^0$.
This represents the hexadecimal number $(3F53)_{16}$ because $15_{10} = F_{16}$.
Converting each hexadecimal digit to its 4-bit binary equivalent yields:
$3_{16} = 0011_2$, $F_{16} = 1111_2$, $5_{16} = 0101_2$, and $3_{16} = 0011_2$.
Concatenating these binary values gives $0011111101010011_2$.
Counting the number of 1s in this binary string, we get $2 + 4 + 2 + 2 = 10$.

In floating-point systems, an exponent $E$ is stored in biased (excess-$N$) notation, where the stored value $E'$ is calculated as $E' = E + \text{bias}$. This transformation maps the range of signed exponents, which include negative and positive values, onto a range of unsigned binary integers $[0, 2^n - 1]$. Consequently, the smallest possible binary representation for the exponent field, consisting of all zeros ($00\dots0$), corresponds to the smallest representable exponent value. This mapping simplifies the comparison of floating-point numbers, as sorting them by their binary representation now yields the correct numerical order.

Signed magnitude range for n bits: -(2^(n-1) - 1) to (2^(n-1) - 1). For 8 bits: -127 to 127.

X = -9, Y = 6, Z = 12. Therefore, 2(6) - 12 = 0 and -9 + 6 + 12 = 9 (Check for specific precision errors if applicable).

Booth's algorithm performs an operation whenever there is a bit transition (0 to 1 or 1 to 0) in the multiplier string.

First write the positive binary for 15 in 5 bits: 01111. To find the 2's complement, invert the bits (10000) and add 1 (10000 + 1 = 10001).

First, write the binary for +17 in 8 bits: 00010001. To find the 2's complement, invert all bits (1's complement = 11101110) and add 1. 11101110 + 1 = 11101111.

Range of n-bit 2's complement is -2^(n-1) to 2^(n-1)-1 → -128 to 127.

9's complement is obtained by subtracting each digit from 9. (9-4)(9-5)(9-6) = 543.

(123)_5 = 125 + 25 + 3 = 38. Then 38 = xy + 8. So xy = 30. If x=3, y=10 (not possible as digit 8 exists), if x=3, y=11 (Wait: 311 + 8 = 41... re-check). If x=3, y=10 -> 38. If digit is 8, base y must be > 8.

101101₂ = 1×32 + 0×16 + 1×8 + 1×4 + 0×2 + 1×1 = 45.

Convert both sides to decimal: (144)_8 = 1(64) + 4(8) + 4 = 100. For the left side: (121)_r = r² + 2r + 1 = (r + 1)². Setting them equal: (r + 1)² = 100, which means r + 1 = 10, thus r = 9. Radix must be positive, so -11 is invalid.

With n-bit sign-magnitude, magnitude uses n−1 bits, so X and Y range from −(2^(n−1)−1) to +(2^(n−1)−1). The largest magnitude of X−Y is 2^n−2, which needs n magnitude bits, plus 1 sign bit. Hence total bits required = n+1.

In the IEEE 754 single-precision (32-bit) format, the exponent is 8 bits long. The standard uses an excess-127 (or bias-127) format, meaning the bias value is 2^(8-1) - 1 = 127.