Digital Logic Design Practice Exam — Free

Draw the map with rows $AB = 00, 01, 11, 10$ and columns $CD = 00, 01, 11, 10$ (Gray-code order, so neighbouring cells differ in exactly one variable), and place a 1 in each listed minterm.

Minterms 0, 2, 8 and 10 occupy the four corner cells (rows $AB = 00$ and $10$, columns $CD = 00$ and $10$). Because the map wraps around both edges, the corners form a single group of four. Across that group $A$ and $C$ both change while $B = 0$ and $D = 0$ stay fixed, so the implicant is $\overline{B}\,\overline{D}$.

Minterms 5, 7, 13 and 15 fill the centre $2\times 2$ block (rows $AB = 01, 11$, columns $CD = 01, 11$). Here $A$ and $C$ change while $B = 1$ and $D = 1$, giving $BD$.

Each group contains a 1 that no other prime implicant covers, so both are essential, and together they cover all eight minterms:

which is simply $B$ XNOR $D$. Spot check: minterm 10 is $A\overline{B}C\overline{D}$, where $\overline{B}\,\overline{D} = 1$, so $F = 1$ as required; minterm 6 is $\overline{A}BC\overline{D}$, where both terms are 0, so $F = 0$, and 6 is indeed absent from the list.

Option B is the common slip: treating the corners as two separate pairs instead of one wrapped group of four leaves $A$ in both terms. Option C fails to merge the two vertical pairs of the centre block. Option D is the complement of the answer ($B$ XOR $D$): it is what you get by grouping the eight 0-cells (minterms 1, 3, 4, 6, 9, 11, 12, 14) instead of the 1-cells.

$F = \overline{B}\,\overline{D} + BD$ (option A).

Convert both operands to binary: 0x6C = 0110 1100 (decimal 108) and 0x45 = 0100 0101 (decimal 69). Add column by column from the right:

  0110 1100
+ 0100 0101
-----------
  1011 0001

The sum is 1011 0001 = 0xB1. There is no carry out of bit 7, so the carry flag is C = 0.

Interpreting 1011 0001 as two's complement: the sign bit is 1, so the value is negative. Its magnitude is found by inverting and adding 1: 0100 1110 + 1 = 0100 1111 = 79, so the result is −79.

Decimal check: 108 + 69 = 177. The largest 8-bit signed value is +127, so 177 does not fit; wrapping around by 256 gives 177 − 256 = −79, which confirms the signed reading.

Overflow is the key observation: two positive operands produced a negative result, which can only happen when the true sum is outside the representable range. Equivalently, the carry into the sign bit (1) differs from the carry out of it (0). Therefore V = 1. Note that C and V are independent: C describes unsigned arithmetic, and 177 fits in an unsigned byte, so C = 0 is correct even though V = 1.

Result 0xB1, signed value −79, V = 1, C = 0.

(a) Decide where each state goes on each input. From S0, a 0 is useless (stay in S0) and a 1 starts a prefix (go to S1). From S1, a 0 breaks the pattern, since 10 is not a prefix of 110 (go to S0), and a 1 gives 11 (go to S2). From S2, a 0 completes 110 (go to S3) and a 1 leaves the last two bits as 11 (stay in S2). From S3, a 0 gives S0, and a 1 is the start of a new pattern (go to S1). With the given encoding, the next-state values $D_1D_0$ and the output are:

(b) $D_1 = 1$ in the rows $Q_1Q_0x = 011, 100, 101$. The last two differ only in $x$ and merge into $Q_1\overline{Q_0}$; 011 has no neighbour, so

$D_0 = 1$ in the rows 001, 100 and 111. No two of these differ in exactly one bit, so nothing merges:

The output of a Moore machine depends only on the state, and only S3 outputs 1, so $z = Q_1Q_0$.

Check by running the stream 1, 1, 0, 1 through the equations: from 00, $x = 1$ gives 01; $x = 1$ gives 10; $x = 0$ gives 11, so $z = 1$ in the cycle after the 0 arrives; then $x = 1$ gives 01, correctly treating that 1 as the start of a new pattern.

$D_1 = \overline{Q_1}Q_0x + Q_1\overline{Q_0}$, $D_0 = \overline{Q_1}\,\overline{Q_0}\,x + Q_1\overline{Q_0}\,\overline{x} + Q_1Q_0x$, $z = Q_1Q_0$.