√(224)_r = 13_r
For f(x) to be maximum
f'(x) = 4x - 2 = 0
⇒ x = 1/2
So at x = 1/2, f(x) is an extremum (either maximum or minimum).
f(2) = 2(2)² - 2(2) + 6 = 10
f(1/2) = 2 × (1/2)² - 2 × 1/2 + 6 = 5.5
f(0) = 6
So, the maximum value is at x=2 which is 10 as there are no other extremum for the given function.

→ When two n-bit binary numbers are added the sum will contain at the most (n+1) bits
Example = 2 Decimal numbers are (7)₁₀ and (7)₁₀
= Equivalent binary numbers are (111)₂ + (111)₂
= Adding two binary numbers, the final result will be n+1 number (1110)₂

(1217)₈=(001 010 001 111)₂
=(0010 1000 1111)₂
=(2 8 F)₁₆

X1= Y1
X2= Y1⊕ Y2
X3= Y2 ⊕ Y3

Given, (12A7C)₁₆ = (0001 0010 1010 0111 1100)₂
MAke blocks of 3 bits each from LSB to MSB.
(Note: In the last block append zeros (as MSBs) if number bits is not three)
(000 010 010 101 001 111 100)
Each of the above blocks represents a digit in base 8 and they can be converted to base 8 as shown below.
= (0 2 2 5 1 7 4)₈

Excess-3 code is also called Self-Complementing Code. Because 1’s complement of an excess-3 number is equivalent to 9’s complement of the corresponding decimal digit.
→ In excess-3 code, each of the 4-bit numbers represents decimal digit which is 3 less than the actual decimal digit. So the bits have no fixed weight.
Excess-3 code is neither CRC nor Algebraic Code which is used for error detection and/or correction.

Hint: Number of bits=4
(Decimal value of maximum 4-bit number +1 )/2= (15+1)/2=8

Number one is 0100 (4-Decimal value)
Another number is 1101(-3 is decimal value)
Adding of -3 and 4, the result is 1 and there is no overflow

Floating Point number in Hexadecimal = C1D00000
Floating Point number in Binary = 1100 0001 1101 0000 0000 0000 0000 0000
In 32-bit, single precision floating point IEEE representation, first MSB represents sign of mantissa: 1 is used to represent a negative mantissa and 0 for a positive value of mantissa, next 8 bits are for exponent value and then 23 bits represents mantissa.
Value of exponent = 131-127 = 4
Mantissa = -1.1010000 0000 0000 0000 0000
Floating point number = -1.1010000 0000 0000 0000 0000
Converting the above one into decimal no -(1*2⁰+1*2^-1*0*2^-2+1*2^-2+0* 2^-3 +.....)
= -(1+½+⅛)=-13/8
Decimal value =sign*Exponent*mantissa=1*4*-13/8

= -26

A floating-point variable can represent a wider range of numbers than a fixed-point variable of the same bit width at the cost of precision. A signed 32-bit integer variable has a maximum value of 2³¹ − 1 = 2,147,483,647, whereas an IEEE 754 32-bit base-2 floating-point variable has a maximum value of (2 − 2⁻²³) × 2¹²⁷ ≈ 3.402823 × 10³⁸.
In the IEEE 754-2008 standard, the 32-bit base-2 format is officially referred to as binary32; it was called single in IEEE 754-1985. IEEE 754 specifies additional floating-point types, such as 64-bit base-2 double precision and, more recently, base-10 representations.
We can convert the binary into decimal representation by using the following steps
let the number of digits in decimal digits be ‘x’
2^-23 = 10^-x
After taking log on both sides
log₂10^-x =log2 2^-23
-x log₂10 = -23log₂2 (The value of log₂2=1)
-3.322 x = -23 (The value of log₂10 = 3.321928)
x = 6.92

Step-1: A binary-coded decimal (BCD) is a class of binary encodings of decimal numbers where each decimal digit is represented by a fixed number of bits, usually four (or) eight.
Step-2: Decimal number 0 can be represented 0000 and 9 can be represented by using 1001.
Step-3: A switch can store maximum 1 bit data that may be either 0 (or) 1. In switch terminology, 0 means “off” and 1 means “on”. With 4 bit we can represent 10 BCD numbers.
Step-4: A BCD digit can be from 0 to 9 (total 10 possibility).
Step-5: Different possible BCD numbers in 12 switches are = 10*10*10
= 1000
= 10³

There are 2​ ⁸​ (256) different possible values for 8 bits. When unsigned, it has possible values ranging from 0 to 255; when signed, it has -128 to 127.

Excess-3 is a self-complementing code. This is because in Excess-3 code we get the 9's complement of a number by just complementing each bit that means by replacing a '0' by '1' and '1' by '0'

• In computers, subtraction is generally carried out by 2’s complement.
• In two's-complement representation, positive numbers are simply represented as themselves, and negative numbers are represented by the two's complement of their absolute value.
• In the subtraction there may possibility of negative number as a result.

Here, 30 digits numbers means 123....30. 10​³⁰​ -1=1000000000000000000000000000000-1=999999999999999999999999999999
Therefore, it takes approximately above 90 binary numbers. So, 120 is correct answer.

Step-1: Convert Hexadecimal numbers into decimal numbers.
(FD)​ _{16<​/sub> = (253)​ 10
(88)​ 16<​/sub> = (136)​ 10
Step-2: Perform subtraction 253-136=(117)​ 10
Step-3: Convert (117)​ 10 ​ =(75)​ 16}

Excess-3 number starts with 3. Here, 1001 menas decimal number-9. So, we have to add +3.
12 equivalent binary number is 1100.

Given Hexadecimal number is ​ (A09D)₁₆
A decimal number is the sum of the digits multiplied with its power of 10.
(A09D)₁₆​ is equal to each digit multiplied with its corresponding power of 16:
Ax16​ ³​ +0x16​ ²​ +9x16​ ¹​ +Dx16​ ⁰​ =(10x4096+144+13x1) [ Where A=10,D=13]
=40960+144+13=41117

→ Sign bit S = 0 (It means positive number)
→ E=1000 0000B = 128D (in normalized form)
→ Fraction is 1.11B (with an implicit leading 1) = 1 + 1×2^-1 + 1×2^-2
= 1.75D
→ The number is +1.75 × 2^(128-127)
= +3.5D

In 2’s complement numbers, the range of integers are from -2^n-1 to 2^n-1 – 1

→ ISO/IEC 646, like ASCII, is a 7-bit character set. It does not make any additional codes available, so the same code points encoded different characters in different countries. Escape codes were defined to indicate which national variant applied to a piece of text, but they were rarely used, so it was often impossible to know what variant to work with and, therefore, which character a code represented, and in general, text-processing systems could cope with only one variant anyway.
→ Extended Binary Coded Decimal Interchange Code (EBCDIC) is an 8-bit binary code for numeric and alphanumeric characters.
→ BCD encoding uses 4 bits to represent each digit from the range 0 to 9 in its binary form.
→ In case of Gray codes, any number of bits can be used to represent a character, according to the requirement.

Binary expression of (3*4096 + 15*256 + 5*16 + 3)
=(12,288+3840+80+3)
=(16211)₁₀
=‭(0011111101010011‬)₂
Total number of 1’s in binary representation is 10.

Consider three digits(1,2,3) of decimal numbers.Maximum number, we can generate by that three digits are 10³-1 which is 999.
Then, Decimal number has 64 digits, so maximum number is 10⁶⁴-1
Similarly, in the binary representation with “n” bits the maximum number is 2ⁿ-1
So we can write 10⁶⁴ –1 = 2ⁿ – 1 --->10⁶⁴ = 2ⁿ
After taking log₂ on both sides
log₂2ⁿ=log₂10⁶⁴
n log₂2=64 log ₂10
n=64*(3.322) [ log₂2=1 & log₂10 =3.322]
n=212.608
n=213

x = 8.8 y=3.5
= 1 (equal priority
Associativity (left to Right)
(((2 * x)/3) * y)
((2 x *) / 3) * y)
(2x * 31) * y
2x * 31) y*
(2x * 31 y*
Put the 2 * 8.8 * 3 / 3.5 *
= 20.53333

Consider three digits(1,2,3) of decimal numbers.Maximum number, we can generate by that three digits are 10^{​ 3}​ -1 which is 999.
Then, Decimal number has 25 digits, so maximum number is 10​ ²⁵​ -1
Similarly, in the binary representation with “n” bits the maximum number is 2​ⁿ​ -1
So we can write 10​ ²⁵​ –1 = 2^{​ n}​ – 1 --->10​ ²⁵​ = 2^{​ n} After taking log​ ²​ on both sides
log​ ₂​ 2^{​ n}​ =log _{​ 2}​ 10^{​ 25}
n log​ ₂​ 2=25 log _{​ 2}​ 10
n=25*(3.322) [ log​ _2​ 2=1 & log_{​ 2}​ 10 =3.322]
n=83

Let base of the number system is r.
(3r² + r + 2) / 2r = (r + 3 + 1/r)
(3r² + r + 2) / 2r = (r² + 3r + 1) / r
(3r² + r + 2) = (2r² + 6r + 2)
r² - 5r = 0
Therefore, r = 5

Step-1: First convert decimal number into binary number
Step-2: (8537)₁₀ = (0010000101011001)₂
Step-3: Divide binary number into 4 segments (0010 0001 0101 1001)₂
Step-4: Write equivalent number of hexadecimal (2159)₁₆

→ The left-shift operator (<<), which moves the bits of shift-expression to the left.
→ The bit positions that have been vacated by the shift operation are zero-filled.
→ For example a=5 and equivalent binary value is 101 and shifting one bit left side means the result binary value is 1010 whose decimal value is 10

Negative numbers are represented in 2’s complement form.
The binary equivalent of 24 is 0000 0000 0001 1000
One’s complement is 1111 1111 1110 0111 (Flipping the bits 1 by 0 and 0 by 1)
Two’s complement is 1111 1111 1110 1000 (adding 1 to the LSB bit)

Consider three digits(1,2,3) of decimal numbers.Maximum number, we can generate by that three digits are 10^{​ 3}​ -1 which is 999.
Then, Decimal number has 25 digits, so maximum number is 10^{​ 25}​ -1
Similarly, in the binary representation with “n” bits the maximum number is 2​ ²⁵​ -1
So we can write 10​ ²⁵​ –1 = 2^{​ n}​ – 1 → 10^{​ 25}​ = 2^{​ n}
After taking log​ ₂​ on both sides
log​ _2​ 2​ ⁿ​ =log _{​ 2}​ 10​ ²⁵
n log​ ₂​ 2=25 log ​ ₂​ 10
n = 25 log ​ ₂​ 10
n = 25 x 3.3 [ log​ ₂​ 2=1 & log​ ₂​ 10 =3.322]
n = 82.5
Note: Original question paper given option D is 60. But actual answer is 82.5.

→ "Gray code" as an alternative name is "reflected binary code". one of those also lists "minimum error code" and "cyclic permutation code" among the names.
→ Gray codes are widely used to facilitate error correction in digital communications such as digital terrestrial television and some cable TV systems.

Extended precision, the third format, is usually an 80-bit word, with 1 bit sign, 15 bit exponent and 64 bit significand, with leading bit of a normalized number not hidden

→ Imagine that we want to design a code with m message bits and r check bits that will allow all single errors to be corrected.
→ Each of the 2​ m​ legal messages has n illegal codewords at a distance of 11 from it.
→ These are formed by systematically inverting each of the n bits in the n-bit codeword formed from it. Thus, each of the 2​ ^m​ legal messages requires n+1 bit patterns dedicated to it.
→ Since the total number of bit patterns is 2​ ⁿ​ ,​ We must have (n+1)2​ ^m​ ≤ 2^{​ n}​ .
→ Using n=m+r, this requirement becomes
= (m+r+1) ≤ 2​ ^r
= 40+6+1 ≤ 2⁶
= 47 ≤ 2
r=6
Message size will be 6+40=46

Algorithm:
Take decimal number is 12.
Step-1 → 12%2 which is equal to 0+10*(⌊12/2⌋)%2
Step-2 → 6%2 which is equal to 0+10*(⌊6/2⌋)%2
Step-3 → 3%2 which is equal to 1+10*(⌊3/2⌋)%2
Step-4 → 1%2 which is equal to 1+10*(⌊1/2⌋)%2

→ The radix of a number system is the number of unique digits, including, zero, that are used to represent larger numbers. In the decimal system that would be 0 to 9.
→ In the question, the unique digits are 0,1 and X(possible x value is 2) then number system is 3;

● Hamming(7,4) is a linear error-correcting code that encodes four bits of data into seven bits by adding three parity bits.
● The data is ​ 0000 and Hamming(7,4) transmitted is 0000000

(4098)​ ₁₀​ =(1000000000010)​ ₂
So, total 13 bits required to represent 4096 decimal number.

Step-1: -33 corresponding positive number 00100001
Step-2: Perform 2’s complement.

11111010 → 250(Decimal)
-11110011 → -243(Decimal)
Step1: convert signed number into 2’s complement
11110011
00001100 → (1’s complement)
+1
-------------
00001101 → (2’s complement)
Step 2: Add 11111010 into 2’s complement number
11111010
00001101
--------------
00000111 → solution

The IEEE 754 standard specifies a binary floating point format(binary32) as having:
→ Sign bit: 1 bit
→ Exponent width: 8 bits
→ Significand precision: 24 bits (23 explicitly stored)

(2374)₈=2x8³+3x8²+7x8¹+4x8⁰=1024+192+56+4=1276

Given number is in base 10. Convert it to base-10.
3.248x10⁴ =32480= 1111110111
= 1.111110111 x 2¹⁴
Mantissa = 11111011100...00
Biased exponent = 14 +127= 141 = 10001101

Step-1: Convert hexadecimal number in binary format. It is nothing but representing 4 binary values of each character.
Step-2: (132A)​ 16​ =(0001 0011 0010 1010)​ ₂ Step-3: Divide 4 binary numbers in to 3 binary numbers from right to left.
Step-4: (0 001 001 100 101 010)​ ₂
(0 1 1 4 5 2)​ ₈

We have to divide binary number into 3 bit pairs from LSB.
1 011 101 011
1 3 5 3
(1011101011)​ ₂​ = (1353)_{​ 8}

Given octal number is 46250 and the corresponding binary number we will get by writing each decimal digit into three binary digits form which is 100110010101000
Now group the four digits from LSB and write corresponding equivalent of Hexadecimal digit of binary digits.
The Hexadecimal number of 100(4) 1100(C) 1010(A) 1000(8) which is nothing but 4CA8

In this problem, they are asking to find (m+n)​ ₄
→ We are using addition for decimal number system. But in this problem m and n values are base 4. So, we can’t add directly.
Step-1: We have to perform base 4 into decimal values of m and n.
m = 3*42 + 1*41 + 3*40
m = 48 + 4 + 3
m = 55
n= 3*42 + 2*41 +2*40
n= 48 + 8 +2
n= 58
Step-2: The resultant decimal values should perform addition.
m+n = 55 + 58
m+n = 113
Step-3: Finally we have to convert decimal value into base 4 value.
(1301)₄

Step-1: Convert octal number into binary number
(2357)​ ₈​ = (010 011 101 111)_{​ 2}
Step-2: Divide 4 bits from LSB then will get hexadecimal number
0100 1110 1111
2 E F
(2EF)​ ₁₆​ = (2357)_{​ 8}

Given data,
→ X is binary number which is power of 2. It means, we have to take powers of 2 numbers only.
Ex: 1,2,4,8,16,32,..,
Let X=4
X=4 equivalent binary number is 100
X-1=3 equivalent binary number is 011
100
011
-----
000 (AND operation)
-----
Ex-2:
X=8 and X-1=7
8 binary value is
1000
7 binary number is 0111
--------
0000(AND operation)
--------
So, Option B is correct answer.

(326.4) ₈ = ( ?)
Step1: First convert given octal no. to binary number because it will be easier to solve this way.

Step 2: Now convert above binary no. into decimal .
(011010110.100) ₂
= ( 1 * 2 ⁷ ) + ( 1 × 2 ⁶ ) + ( 1 × 2 ⁴ ) + ( 1 × 2 ² ) + ( 1 × 2 ¹ ) · [ 1 × ( 1/2) ]
= (214.5) ₁₀
(326.4) ₈ = (?) ₁₆ Step 1: Convert given octal no. into binary no.

Step 2: Now convert above binary no. into decimal .
(011010110.100) ₂
= ( 1 * 2 ⁷ ) + ( 1 × 2 ⁶ ) + ( 1 × 2 ⁴ ) + ( 1 × 2 ² ) + ( 1 × 2 ¹ ) · [ 1 × ( 1/2) ]
= (214.5) ₁₀
(326.4) ₈ = (?) ₁₆

2’s complement has single representation for zero , but Sign-magnitude, 1’s complement and 9’s complement have two representations for 0 (i.e., both positive zero and negative zero). While doing arithmetic operations like addition or subtraction using 1's complement(or 9's complement), we have to add an extra carry bit, i.e 1 to the result to get the correct answer. 2's complement doesn't require such extra calculation.

Option-A: 1100 convert into 2’s complement is
1100
1’s complement: 0011
2’s complement: 1
--------
0100
Option-B: 1001 convert into 2’s complement is
1001
1’s complement: 0110
2’s complement:
1
--------
0111
---------
Option-C: 1000 convert into 2’s complement is
1000
1’s complement: 0111
2’s complement:
1
--------
1000
---------
Option-D: 1111 convert into 2’s complement is
1111
1’s complement: 0000
2’s complement:
1
--------
0001
---------
So, Option-C is correct answer.

Option-A: (100101100)​ ₂​ = (300)​ ₁₀
300 is divisible by 4
Option-B: (1110001110001)​ ₂​ = (7281)_{​ 10}
7281 is not divisible by 4
Option-C: (11110011)​ ₂​ = (243)​ ₁₀
243 is not divisible by 4
Option-D: (10101010101010)​ ₂​ = (10,922)_{​ 10}
10,922 is not divisible by 4.

We are dividing binary number into 3 then
101 011
5 3
(101011)​ ₂ = (53)​ ₈
Suppose, we are dividing binary digits into 4 then
0010 1011
2 B
So, it is not hexadecimal number.

Option-A: 1010 convert into 2’s complement is
1010
1’s complement: 0101
2’s complement: 1
--------
0110
--------- Option-B: 0101 convert into 2’s complement is
0101
1’s complement: 1010
2’s complement: 1
--------
1011
---------
Option-C: 1000 convert into 2’s complement is
1000
1’s complement: 0111
2’s complement: 1
--------
1000
---------
Option-D: 1001 convert into 2’s complement is
1001
1’s complement: 0110
2’s complement: 1
--------
0111
---------
So, Option-C is correct answer.

Step-1: First convert binary number into decimal number
(10111)​ ₂​ = (23)_{​ 10}
(1110)​ ₂​ = (14)​ ₁₀
Step-2: Perform multiplication 23*14=(322)​ ₁₀
Step-3: Convert (322)​ ₁₀​ into hexadecimal number (322)​ ₁₀​ = (142)_{​ 16}

→ Excess-3 code is also called Self-Complementing Code. Because 1’s complement of excess-3 number is equivalent to 9’s complement of corresponding decimal digit.
→ In excess-3 code, each of the 4-bit number represents decimal digit which is 3 less than actual decimal digit. So the bits have no fixed weight.
→ Excess-3 code is ​ neither​ CRC ​ nor​ Algebraic Code which are used for error detection and/or correction.

(3*512 + 7*64 +5*8 +3) =2027
(2027)​ ₁₀​ = (111 1110 1011)_{​ 2}
Here, total number of 1’s are 9.

The decimal value 5 is represented by 1011.
= 6*1 + 4*0 + 2*1 + -3*1
= 6+2-3
=5

→ Each digit is represented by a 4-bit BCD code.
→ To add two 4-bit number, we need 1 Half Adder(to add LSBs) and 3 Full Adders(remaining three bits of both number along with carry bits).
→ To make the resultant Sum as valid BCD sum, we need to add 0110 to the sum.
→ This can be done with 1 Half adder and 2 Full Adder
(Note: LSB bit of 0110 is always zero. So there is no need of ADDER to add LSBs.)
→ Here, Half adder is used to add next significant bits.
Total 5 Full Adders and 2 Half Adders are needed

The Excess-3 decimal code is a self-complementing code because complement can be generated by inverting each bit pattern.

The range of representable normalized numbers in the floating point binary fractional representation in a 32-bit word with 1-bit sign, 8-bit excess 128 biased exponent and 23-bit mantissa is​ ​ 2 ^–129 to (1 – 2​ ^–23​ ) * 2^{​ 127}

1. Fraction part can be converted into binary form by multiplying it with 2 and taking non fractional part of the product. Take fractional part and multiply again as explained above.
0.1 x 2= 0.2 → 0
0.2 x 2= 0.4 → 0
0.4 x 2= 0.8 → 0
0.8 x 2= 1.6 → 1
0.6 x 2= 1.2 → 1
(0.1)​ ₁₀​ = (0.00011)​ ₂
(40)​ ₁₀​ = (101000)​ ₂
101000.00011
Normalize the number
1.0100000011 x 2​ ⁵
Biased exponent= 5+127= 132=(1000 0100)_{​ 2}
Mantissa= 01000000110000000000000
Sign= 1

The IEEE single-precision and double-precision format to represent floating-point numbers, has a length of 32 bits and 64 bits respectively.

Option-A: It is false because it is equivalent to (292)₁₀ =(100100100)₂ Option-B: It is false because it is equivalent to (292)₁₀ =(444)₈ Option-B: It is false because it is equivalent to (292)₁₀ =(292)₁₀ So, option-D is the correct answer. The actual x value is 6.

= If an integer needs two bytes of storage, then the maximum value of a signed integer is 2^n-1 -1
= 2¹⁵ -1

= If an integer needs two bytes of storage, then the maximum value of a signed integer is 2^n-1 -1
= 2¹⁵ -1

Negative numbers can be represented in
1. Signed magnitude form
2. 1’s complement form
3. 2’s complement form

(1762.46)₈
→ For making the conversion easy, first convert number into binary
(001 111 110 010. 100 110)₂
→ Now convert above binary no. into hexadecimal, we need 4-bits to represent a no. into hexadecimal

(3F2.98)₁₆

(-77.25)₁₀ Step 1: Convert (77)₁₀into binary form.

Step-1: 2's complement number are weighted number. So, 1101010= -1*(0.26) + 1*25 + 1*23 + 1*21 = -64 + 32 +8 +2 = -22 Hence (1101010)=(-22) in 2's complement form

(m) Data = 0011
No. of parity bits needed is decided using
2^p≥ m+p+1
p=3
Bit pattern:

P₁(check even parity at 1, 3, 5, 7 bit) = 0
P₂(check even parity at 2, 3, 6, 7 bit) = 1
P₄(check even parity at 4, 5, 6, 7 bit) = 1
So encoded data = 0011110

The question is not properly framed.
In the question it is mentioned that 11011.1100 is BCD.
We know that BCD code is different from Binary number system.
Each of the decimal digit has a 4-bit binary code or in other words every block of 4 bits has a corresponding decimal digit.
0000- 0
0001- 1
:
:
1001- 9
1010 - 1111 are not valid codes.
If the given code 11011.1100 is BCD then divide it into blocks of 4 bits.
0001 1011. 1100 (Note: Appending zeros on the left side will not change value.)
But 1011 is not a valid BCD code.

Given expression is 3 × 512 + 7 × 64 + 5 × 8 + 3
We can write above statement based on precedence is (3 * 512) + (7 * 64) + (5 * 8) + 3
Step-1: 1536+448+40+3
Step-2: (2027)₁₀
Step-3: Equivalent binary number is (‭011111101011‬)₂
Note: Total number of 1’s is 9.

Step-1: Convert FF into binary number
(FF)₁₆ = (1111 1111)₂
Step-2: Divide binary number into 3 segments from LSB(Least significant bit).

Step-1: The precedence to given decimal number is (15*256) + (5*16) + 3
Step-2: 3840+80+3=(3923)¹⁰
Step-3: Convert decimal number into binary
(3923)¹⁰ = (‭111101010011‬ )₂
Step-4: Total number of 1’s are 8.

A binary linear code with minimum distance 2t + 1 then it can correct up to ‘T’ bits of error.