Unit 1 - Practice Quiz

An analog signal is continuous and can have an infinite number of values within its range, unlike a digital signal which is discrete and can only take on a finite number of values.

The decimal number system uses 10 unique digits (0, 1, 2, 3, 4, 5, 6, 7, 8, 9), so its base (or radix) is 10.

The binary number system has a base of 2 and only uses two digits: 0 and 1. The number 10210 contains the digit '2', making it an invalid binary number.

To convert to decimal, we use the positional weights: .

The octal number system has a base of 8 and uses the eight digits from 0 to 7.

The hexadecimal system uses digits 0-9 and letters A-F. A represents 10, B represents 11, C is 12, D is 13, E is 14, and F is 15.

In binary addition: (rightmost bit). with a carry of 1 (next bit). The final result is . In decimal, this is .

The 1's complement is found by inverting each bit of the binary number. Every 1 becomes a 0, and every 0 becomes a 1. So, 110100 becomes 001011.

In sign-magnitude representation, the leftmost bit (MSB) is the sign bit. A '0' typically indicates a positive number, and a '1' indicates a negative number.

In BCD, each decimal digit is represented by its own 4-bit binary equivalent. The decimal digit '3' is 0011 in binary, and '9' is 1001. So, 39 in BCD is 0011 1001.

Gray code is an unweighted code where consecutive numbers differ by only one bit. This property is crucial for reducing errors in electromechanical systems.

The data 11010 has three '1's (an odd number). To achieve odd parity, the total number of '1's (including the parity bit) must be odd. Since the count is already odd, the parity bit must be '0'.

A parity check adds a single bit to data to make the total count of 1s either even or odd. If one bit flips during transmission, the parity count at the receiver will be incorrect, thus detecting the error.

The core principle of a digital system is that it operates on information represented by discrete (separate and distinct) values, most commonly binary digits (0s and 1s).

Logic gates (such as AND, OR, NOT) are the fundamental electronic circuits that perform basic logical operations and are the building blocks for more complex digital circuits.

Error correction codes, like Hamming code, contain enough redundant information to allow the receiver to identify the location of an error and correct it.

A floating-point number consists of a mantissa (the significant digits) and an exponent. The exponent specifies how many places to shift the radix point in the mantissa.

To convert from binary to hexadecimal, we can group the binary digits into sets of four. is one group. In decimal, this is . The decimal value 13 is represented by the letter 'D' in hexadecimal.

In decimal, . To represent 9 in octal (base 8), we have one group of 8 and a remainder of 1. Therefore, .

In decimal, . The decimal value 13 is represented by the letter 'D' in the hexadecimal number system.

To add the hexadecimal numbers, we add them column by column from right to left, carrying over when the sum exceeds 15.

1. Rightmost column: , which is in hexadecimal. No carry.
2. Middle column: . Since , we find . So, we write down 8 and carry over 1.
3. Leftmost column: , which is in hexadecimal.
   The final result is .

The conversion is done in two parts:

1. Integer Part (27): Convert 27 to binary by successive division by 2 or by sum of powers of 2. , which is .
2. Fractional Part (0.375): Convert 0.375 to binary by successive multiplication by 2.
   • (Integer part is 0)
   • (Integer part is 1)
   • (Integer part is 1)
     Reading the integer parts from top to bottom gives .
     Combining both parts, we get .

To find the 2's complement of a negative number:

1. First, find the 8-bit binary representation of its positive counterpart, +75. .
2. Next, find the 1's complement by inverting all the bits: .
3. Finally, find the 2's complement by adding 1 to the 1's complement: . This is the representation for -75.

To convert a binary number to Gray code:

1. The Most Significant Bit (MSB) of the Gray code is the same as the MSB of the binary number. So, .
2. For the next bits, XOR the current binary bit with the previous binary bit.
   • 
     The resulting Gray code is 11101.

To find the error, we check the parity of three groups of bits:

• Check P1 (positions 1, 3, 5, 7): Bits are 1, 1, 0, 0. There are two 1s (even). Parity check is OK. Error bit .
• Check P2 (positions 2, 3, 6, 7): Bits are 0, 1, 0, 0. There is one 1 (odd). Parity check fails. Error bit .
• Check P4 (positions 4, 5, 6, 7): Bits are 1, 0, 0, 0. There is one 1 (odd). Parity check fails. Error bit .
  The error position is given by the binary number formed by the check bits . Here, it is , which is 6 in decimal. Therefore, the bit at position 6 () is in error.

We perform addition column by column, from right to left:

1. Rightmost column: . In base 8, . Write down 2, carry over 1.
2. Middle column: . In base 8, . Write down 3, carry over 1.
3. Leftmost column: . In base 8, . Write down 0, carry over 1.
4. The final carry becomes the new MSB. The result is .

First, perform binary addition on the BCD numbers:

Now, check each 4-bit nibble. The left nibble is , which is valid in BCD (<=9). The right nibble is , which is invalid in BCD (>9).
To correct an invalid nibble, we add 6 () to it.
. The result is $0000$ with a carry of 1 to the next nibble.
Now, add this carry to the left nibble: . This is valid.
The final BCD result is , which represents 90.

The bias for an IEEE 754 floating-point number is calculated as , where 'k' is the number of bits in the exponent field. For the single-precision format, k=8. Therefore, the bias is . The actual exponent is found by subtracting this bias from the value stored in the exponent field.

The operation is performed as in 2's complement.

1. Binary representation of +20 is .
2. To find -45, first find +45: .
3. Find the 2's complement of +45: Invert the bits to get (1's complement), then add 1 to get (-45).
4. Now, add the two numbers:
   $00010100$ (+20)

   • $11010011$ (-45)

     $11100111$
     The result is . To verify, since the MSB is 1, it's a negative number. Its magnitude is the 2's complement of the result: invert ($00011000$) and add 1 (). So the answer is -25, which is correct.

Odd parity requires the total number of '1's in the codeword (data + parity bit) to be odd.
The data word 1011001 has four '1's, which is an even number.
To make the total count of '1's odd, the parity bit must be a '1'.
Therefore, the transmitted codeword is the original data with a '1' appended: 10110011.

A simple parity check can only detect the presence of an odd number of bit errors (e.g., a single-bit error). It cannot determine which bit is wrong. The primary advantage of a Hamming code is its ability to not only detect a single-bit error but also to pinpoint its exact location, thereby allowing for its correction.

The most straightforward method is to convert from octal to binary, and then from binary to hexadecimal.

1. Octal to Binary: Convert each octal digit to its 3-bit binary equivalent.
   • 
     Combining these gives .
2. Binary to Hexadecimal: Group the binary string into sets of 4 bits, starting from the right.
   • Convert each 4-bit group to its hexadecimal equivalent:
     • 
       The result is .

In the signed magnitude representation, the Most Significant Bit (MSB) represents the sign, and the remaining bits represent the magnitude.

• The MSB is '1', which indicates a negative number.
• The remaining 7 bits are 0101100. We convert this magnitude to decimal:
  .
  Combining the sign and magnitude, the decimal value is -44.

The relationship between the number of data bits (m) and parity bits (p) in a Hamming code is given by the inequality . We need to find the smallest integer 'p' that satisfies this for m=8.

• If p=3: . Is ? Is ? No.
• If p=4: . Is ? Is ? Yes.
  Therefore, the minimum number of parity bits required is 4.

The subtraction is performed as where is the 2's complement of B.

1. A = . In a 6-bit system, this is .
2. B = . In a 6-bit system, this is .
3. Find the 2's complement of B ():
   • Invert the bits (1's complement):
   • Add 1:
4. Add A and (-B):
   $010110$

   • $100101$

     $111011$
     The result is . This represents , which is the correct answer for .

To convert a hexadecimal number to decimal, we multiply each digit by its corresponding power of 16 and sum the results.

• A in hexadecimal is 10 in decimal.
• C in hexadecimal is 12 in decimal.
  So, the expression becomes:
  
  
  .

1. The generator polynomial corresponds to the binary divisor 1011. The degree is 3.
2. Append 3 zeros (the degree of G(x)) to the data: 110101000.
3. Perform binary division (modulo-2) of 110101000 by 1011.
   The division process yields a remainder of 111.
4. The CRC remainder (111) is appended to the original data (110101) to form the codeword.
   Codeword = Data + Remainder = 110101111.

The defining property of Gray code is that only a single bit flips when moving from one value to the next consecutive value. In mechanical encoders, this prevents ambiguous or erroneous readings during the transition between adjacent positions. If multiple bits were to change at once (as in standard binary), a slight misalignment could cause the sensor to read an incorrect intermediate state.

To convert a decimal number to octal, we use successive division by 8 and record the remainders.

1. with a remainder of 7.
2. with a remainder of 3.
3. with a remainder of 2.
   Reading the remainders from the bottom up gives the octal number . To check: .

For a system with 'n' bits, the range of values that can be represented in 2's complement form is from to .
For n=8:

• The lower bound is .
• The upper bound is .
  Thus, the range is -128 to +127. This asymmetrical range is because there is one representation for zero and the most negative number does not have a positive counterpart.

The parity checks are:

• (bits 1, 3, 5, 7): (Error)
• (bits 2, 3, 6, 7): (Error)
• (bits 4, 5, 6, 7): (Error)
  The syndrome is C4 C2 C1 = 111, which is 7 in decimal. This indicates that bit 7 (D7) is in error. The received codeword is 1011011. Flipping bit 7 gives the corrected codeword 1011010. The data bits are D3, D5, D6, D7, which are at positions 3, 5, 6, 7. So the corrected data word is 1010. Let's re-read the question's format (P1 P2 D3 P4 D5 D6 D7).
  Received: P1=1, P2=0, D3=1, P4=1, D5=0, D6=1, D7=1.
• C1 checks P1, D3, D5, D7: (Error)
• C2 checks P2, D3, D6, D7: (Error)
• C4 checks P4, D5, D6, D7: (Error)
• C1 (P1,D3,D5,D7): . Error. Syndrome bit = 1.
• C2 (P2,D3,D6,D7): . Error. Syndrome bit = 1.
• C4 (P4,D5,D6,D7): . Error. Syndrome bit = 1.
• P1 (1,3,5,7): (OK)
• P2 (2,3,6,7): (OK)
• P4 (4,5,6,7): (OK)
  This has no error. Let's try 1101010.
• P1 (1,3,5,7): (Error) -> C1=1
• P2 (2,3,6,7): (OK) -> C2=0
• P4 (4,5,6,7): (OK) -> C4=0
• P1(1,3,5,7): (OK)
• P2(2,3,6,7): (OK)
• P4(4,5,6,7): (OK)
  This is a valid codeword for data 1111. Transmitted: P1=0,P2=0,P4=0 -> 0010111. Let's corrupt D5 (bit 5). Transmitted 0010111, received 0010011.
• P1(1,3,5,7): (OK)
• P2(2,3,6,7): (Error) -> C2=1
• P4(4,5,6,7): (OK)
  My check groups are wrong. P1->1,3,5,7. P2->2,3,6,7. P4->4,5,6,7. Let's re-verify. Correct. Okay, re-run the 0010011 example. Data is D3=1, D5=0, D6=1, D7=1. Codeword is P1 P2 1 P4 0 1 1. Even Parity. P1 = D3+D5+D7 = 1+0+1=0. P2=D3+D6+D7=1+1+1=1. P4=D5+D6+D7=0+1+1=0. Correct codeword: 0110011. Let's corrupt D5 (bit 5). Received 0110111. Now check this.
• P1(1,3,5,7): (Error) -> C1=1
• P2(2,3,6,7): (OK) -> C2=0
• P4(4,5,6,7): (Error) -> C4=1
  Syndrome C4C2C1 is 101, which is 5. Error in bit 5. Correct. The received data D3D5D6D7 was 1111. Bit 5 is D5. So we flip D5 from 1 to 0. Corrected data is 1011. This is a good question.
  Final question: Received codeword 0110111. Data D3, D5, D6, D7. Find corrected data.

In the IEEE 754 single-precision format, a denormalized number is indicated by an exponent field of all zeros. The formula for a denormalized number is , where F is the 23-bit fraction. The smallest positive value occurs when S=0 and the fraction F is minimized. The smallest non-zero fraction is a 1 in the least significant bit position, which corresponds to a value of . Therefore, the smallest positive denormalized number is .

Multiplication by 2 in binary is equivalent to an arithmetic left shift by one position. The number is 10110101. Shifting left gives 01101010 and the MSB 1 is discarded. The new sign bit is 0. Let's verify this using decimal values. The number 10110101 is negative. Its magnitude is the 2's complement of 10110101, which is 01001011. This is . So the original number is -75. Multiplying by 2 gives -150. An 8-bit 2's complement system can represent numbers from -128 to +127. So -150 causes an overflow. However, the question asks for the result of the bit-wise operation. The bit pattern 01101010 in 8-bit 2's complement is a positive number equal to . The overflow changes the sign, leading to an incorrect but mechanically derived result. The question specifically asks for the bit-wise operation result, not whether it's arithmetically correct.

We perform long division in base 16.
First, convert to decimal for verification: .
.
. Let's do the hex division directly.

1. How many times does go into ? . . . Let's try a smaller number, like 7. .
   . No, . So, . Remainder is 8. Bring down F. We have .

2. . First, . . But . Try . . Bring down E. Have .

3. . ? . . . So 4 is the digit. . Bring down F. Have .

4. . . . . So E is the digit. . Something is wrong.
   Let's retry the verification: .
   .
   . .
   . . . This doesn't match.
   Okay, there is an error in my arithmetic. Let's trust the logic and re-calculate.
   New Question: .
   . . with remainder $13$. . . So Q=, R=. This is a good problem. I will replace the old one.

The original number is . Assuming this is a 2's complement number, the MSB is the sign bit. An arithmetic right shift preserves the sign bit.

1. Shift right: The bits shift right, and the MSB is copied into the now-empty MSB position. . So, .
2. Convert to Gray code. The formula is (with ).
   • 
     The resulting Gray code is 1001.

This is a single-error correcting code similar to Hamming code. We need to calculate the syndrome by re-checking the parity. Received data: . Received parity: .

1. Check : . Received . There is a mismatch. Syndrome bit .
2. Check : . Received . This matches. Syndrome bit .
3. Check : . Received . There is a mismatch. Syndrome bit .
   The syndrome vector is 101. We now need to identify which bit error would cause this syndrome.
   • Error in affects . Syndrome would be 011.
   • Error in affects . Syndrome would be 101.
   • Error in affects . Syndrome would be 110.
   • Error in affects . Syndrome would be 111.
   • Error in affects only check. Syndrome 001.
   • Error in affects only check. Syndrome 010.
   • Error in affects only check. Syndrome 100.
     Our calculated syndrome is 101, which corresponds to an error in data bit .

The numbers are and . The expected result is .

1. Perform binary addition on the BCD nibbles:
   0100 1001

   • 0101 0111

     1001 1111

2. Check each nibble for validity. The lower nibble is 1111 (), which is greater than 9, so it's an invalid BCD digit. The higher nibble is 1001 (), which is valid.
3. Correct the invalid lower nibble by adding 6 ():
   1111 + 0110 = 1 0101. A carry of 1 is generated.
4. Add the carry to the next higher nibble:
   1001 (original higher nibble) + 1 (carry) = 1010.
5. The new higher nibble 1010 () is also greater than 9 and thus invalid. Correct it by adding 6 ():
   1010 + 0110 = 1 0000. Another carry of 1 is generated.
6. The final result is formed by the new carry and the corrected nibbles:
   Carry: 0001 (representing the hundreds place)
   Higher nibble: 0000
   Lower nibble: 0110
   Combining these, the final BCD result is 0001 0000 0110, which represents .

An n-bit system has possible bit patterns.

• Sign-Magnitude: Has two representations for zero: 000...0 (+0) and 100...0 (-0). This redundancy means it can only represent unique numerical values.
• 1's Complement: Also has two representations for zero: 000...0 (+0) and 111...1 (-0, the bitwise complement). This also results in unique numerical values.
• 2's Complement: Has only one representation for zero (000...0). All bit patterns map to a unique numerical value. The range is asymmetric, from to .
  Therefore, 2's Complement can represent exactly one more unique value than the other two systems because it does not have a redundant representation for zero.

The number can be written in scientific notation as . In the IEEE 754 single-precision format, this is represented with:

• Sign bit: 0 (positive)
• Exponent: The biased exponent is . Here, , so .
• Mantissa: The number is exactly , so the fractional part is all zeros: . (The leading 1 is implicit).
  The value of a number is . The ulp, or the value of the least significant bit of the mantissa, determines the gap to the next number. This value is .
  For the number , the exponent is 24. Therefore, the gap is . The next representable number is .

We can perform long division in base 8 or convert to decimal to verify.
Decimal Verification:
.
.
.
Now, convert the quotient back to octal: R 7. R 0. R 2. Reading remainders bottom-up gives . The remainder is 0.
Octal Long Division:

1. Divide by . , . . So the first digit is 2. . Subtract: . Bring down 2. We have .
2. Divide by . It doesn't go, so the next digit is 0. Bring down 4. We have .
3. Divide by . . . . So the last digit is 7. . Subtract: .
   The quotient is and the remainder is .

A self-complementing code is one where the 9's complement of a decimal digit can be obtained by taking the bitwise complement (1's complement) of its binary code representation. Let's test this with an example. Decimal 2 is 0101 in Excess-3. Its 9's complement is 7, which is 1010 in Excess-3. The bitwise complement of 0101 is 1010. This holds true for all digits. For example, 3 is 0110 and its 9's complement 6 is 1001, which is the bitwise inverse. This property simplifies hardware for subtraction operations using complements.

The Hamming distance is the number of bit positions in which two codewords differ. We must find the minimum distance between all possible pairs of codewords:

• d(00111, 11100) = 4
• d(00111, 01010) = 3
• d(00111, 10001) = 3
• d(11100, 01010) = 4
• d(11100, 10001) = 3
• d(01010, 10001) = 5
  The minimum of these distances is .
  The error detection capability is given by . So, this code can detect up to bit errors.
  The error correction capability is given by . So, this code can correct up to bit error.

When multiplying two fixed-point numbers, the number of integer bits in the result is the sum of the integer bits of the operands, and the number of fractional bits in the result is the sum of the fractional bits of the operands.

• Number A is in Qm1.n1 format where m1=4 integer bits and n1=4 fractional bits.
• Number B is in Qm2.n2 format where m2=2 integer bits and n2=6 fractional bits.
  The product will be in Qm_res.n_res format.
• The number of integer bits in the result is .
• The number of fractional bits in the result is .
  The resulting 16-bit number () will be in Q6.10 format.

. Same result.
There must be a typo in the question or my understanding. Let's re-examine . That doesn't work. Let's check the options.
If b=4: . $25
e 48$.
If b=5: . $36
e 48$.
If b=6: . We have .
The original equation was .
.
.
So $50
e 49(121)_b = (100)_7 - 1$.
Let's assume the question meant: . Then . Let's rewrite the question to be solvable. "Solve for base 'b' if ." No, that's too simple. Let's make it more complex.

The range of an 8-bit 2's complement system is from -128 to +127. The most negative number is -128, which is represented as 10000000. To find its 2's complement, we first find the 1's complement (invert all bits) and then add 1.

1. Original number: 10000000 (-128)
2. 1's Complement (invert bits): 01111111
3. Add 1: 01111111 + 1 = 10000000.
   The result is the same as the original number. This is a special case in 2's complement arithmetic where negating the most negative number results in an overflow and yields the number itself, as its positive counterpart (+128) cannot be represented in 8 bits.

The system needs to represent 12 unique states. The minimum number of bits required is bits.

• One-hot encoding: Would require 12 bits (e.g., Jan=0...001, Feb=0...010), which is inefficient. The Hamming distance is 2, but bit count is high.
• Standard 4-bit binary: Uses the minimum 4 bits, but the Hamming distance can be 1 (e.g., between 0001 (1) and 0011 (3), or 0001 and 0000). Thus, it cannot guarantee detection of single-bit errors.
• 4-bit Gray code: Also uses 4 bits, but adjacent codes have a Hamming distance of 1 by definition, so it fails the error detection requirement.
• 5-bit code with parity: This scheme uses a 4-bit binary representation (0000 to 1011 for months 1-12) and adds a 5th bit for parity. The addition of a parity bit ensures that the minimum Hamming distance between any two valid codewords is at least 2. Any single-bit flip will result in an invalid parity, allowing the error to be detected. While it uses 5 bits instead of 4, it's the most bit-efficient option presented that meets the Hamming distance requirement for single-error detection.

In a 2D parity check, a single data bit error at position (r, c) flips the parity of row 'r' and column 'c', allowing for error correction. However, this question describes a double-bit error. Let the data bit at (r1, c1) be flipped, and a parity bit be flipped. There are two cases:

1. A row parity bit is flipped: Let's say parity bit for row r2 is flipped. The flip at (r1, c1) affects row r1 and column c1. If r1 = r2, the error in row r1 is masked (two flips), leaving only column c1 with bad parity. This looks like an error in the column parity bit for c1, not a data error. If r1 != r2, row r1, row r2, and column c1 will all show bad parity. This pattern does not correspond to a single-bit error.
2. A column parity bit is flipped: Similar to the above, if the column matches (c1=c2), the column error is masked, and only row r1 shows bad parity, pointing incorrectly to the row parity bit for r1. If c1 != c2, then row r1, column c1, and column c2 show bad parity.
   In all cases, the resulting syndrome does not match the pattern of a single, correctable data-bit error. The error is detected, but its location cannot be determined correctly and may be misidentified.

First, represent the numbers in 4-bit 2's complement.
M = Multiplicand = -5 = 1011
Q = Multiplier = -3 = 1101
We need an 8-bit result space (A and Q registers). Initialize A = 0000 and an extra bit Q-1 = 0. The product will be in A and Q.

Initial State: A=0000, Q=1101, Q-1=0. Product size is 8 bits.

Step 1: Last two bits of (Q, Q-1) are 10. This means A = A - M.
M = 1011. -M (2's complement of M) = 0101.
A = 0000 + 0101 = 0101.
Arithmetic Right Shift [A, Q, Q-1]: 0010 1110 1.

Step 2: Last two bits of (Q, Q-1) are 01. This means A = A + M.
A = 0010 + 1011 = 1101.
Arithmetic Right Shift [A, Q, Q-1]: 1110 1111 0.

Step 3: Last two bits of (Q, Q-1) are 10. This means A = A - M.
A = 1110 + 0101 = 0011 (carry discarded).
Arithmetic Right Shift [A, Q, Q-1]: 0001 1111 1.

Step 4: Last two bits of (Q, Q-1) are 11. This means no operation.
Arithmetic Right Shift [A, Q, Q-1]: 0000 1111 1.

M = 1011, -M = 0101. Q = 1101. A=0000, Q-1=0.

1. (Q0, Q-1) = (1,0). A=A-M. A = 0000+0101=0101. Shift [A,Q,Q-1] -> [0010, 1110, 1].
2. (Q0, Q-1) = (0,1). A=A+M. A = 0010+1011=1101. Shift -> [1110, 1111, 0].
3. (Q0, Q-1) = (1,0). A=A-M. A = 1110+0101=0011. Shift -> [0001, 1111, 1].
4. (Q0, Q-1) = (1,1). No op. Shift -> [0000, 1111, 1].
   Result 00001111. Yes, this is correct. Let's try another multiplication, e.g., . M=6=0110, -M=1010. Q=-2=1110.
   Initial: A=0000, Q=1110, Q-1=0.
5. (0,0) -> Shift -> [0000, 0111, 0].
6. (1,0) -> A=A-M -> A=0000+1010=1010. Shift -> [1101, 0011, 1].
7. (1,1) -> Shift -> [1110, 1001, 1].
8. (1,1) -> Shift -> [1111, 0100, 1].
   Result: 11110100. This is 2's complement of 00001100, which is 12. So result is -12. Correct. The first three bits are 111. Let's re-frame the question to this. New question: M=6 (0110), Q=-2 (1110). The old one gave a trivial MSB answer.

Infinity in IEEE 754 is represented by an exponent field of all 1s and a mantissa (fraction) of all 0s.

• Sign bit: For negative infinity, the sign bit S is 1.
• Exponent field: For infinity, this 8-bit field is all 1s: 11111111.
• Mantissa field: For infinity, this 23-bit field is all 0s: 000...0.
  Combining these fields gives the 32-bit pattern:
  S | Exponent | Mantissa
  1 | 11111111 | 00000000000000000000000
  Grouping into 4-bit nibbles for hexadecimal conversion:
  1111 1111 1000 0000 0000 0000 0000 0000
  This translates to:
  F F 8 0 0 0 0 0
  So, the hexadecimal representation is FF800000.

This is a two-step problem. First, find the base 'b'.

1. Convert the binary number to base 10:
   .
2. Set the base 'b' polynomial equal to 50:
   
   
   .
   We need to find integer factors of -48 that sum to +3. This is not possible. Let me check my binary to decimal. . Correct. . Quadratic formula: . This does not yield an integer base.
   Let me re-create a solvable problem. Let's pick b=7. . . So the question could be . Let's try b=6. . . Let's use this. New question: . So .
   Now the second part: find in base 10.
   , so . We need to find in base 10. The digits 2, 6, 1 are all valid in base 7.
   .
   Final check: . . . Correct. Find . . Final answer is 141. I will set the correct option to this.