Digital Design Interview Questions - v1.1

Q.1) Implement OR and NOR using 2-to-1 multiplexer.

Answer) OR gate:
               Multiplexer equation: Y = I1.(S) + I0.not(S)
                                 I1 => '1' ; I0 => 'B' ; S => 'A'
                                                Y = 1.(A) + B.not(A)      
              Upon simplifying above equation, Y = A + B
               

                                               

                 











                NOR gate:
                Multiplexer equation: Y = I1.(S) + I0.not(S)
                                 I1 => '0' ; I0 => 'not(B)' ; S => 'A'
                                                Y = 0.(A) + not(B).not(A)      
                Upon simplifying above equation, Y = not(A+B)

                                           

Q.2) Implement EX-OR and EX-NOR gates using 2-to-1 multiplexer.

Answer) EX-OR gate:

               Multiplexer equation: Y = I1.(S) + I0.not(S)
                                 I1 => 'not(B)' ; I0 => 'B' ; S => 'A'
                                                Y = not(B).(A) + B.not(A)  
    

                                         
               

               EX-NOR gate:

               Multiplexer equation: Y = I1.(S) + I0.not(S)
                                 I1 => 'B' ; I0 => 'not(B)' ; S => 'A'
                                                Y = B.(A) + not(B).not(A)  

                                        

Q.3) Implement latch using 2-to-1 multiplexer.

Answer) Multiplexer equation: Y = I1.(S) + I0.not(S)

                                 I1 => 'D' ; I0 => 'Q' ; S => 'En'
                                                Y = D.(En) + Q.not(En)

Q.4) Implement D flip-flop using 2-to-1 multiplexer.

Answer) In the below implementation of flip flop, two muxes are used. The flip flop shown below is a negedge D flip flop.

Q.5) Implement T flip-flip using 2-to-1 multiplexer.

Answer) T flip-flop using D flip-flop :

Digital Design Interview Questions - v1.0

Q.1) Implement inverter using NAND Gate?

Answer)  The key to solving such type of questions is, first draw the truth table of the gate given and then the table for what you want to achieve.
           
             

Truth table for AND and INVERTER Gate

                  From the truth table,

                         when both inputs => 0, output => 1 (same as inverter)

                         when both inputs => 1, output => 0 (same as inverter)

                 

                   Implementation of Inverter using NAND Gate.

Inverter using NAND gate

                    Another Implementation :

Inverter using NAND gate

                     NAND Expression : Y = not(A) or not (B)

                     If B => 1

                     Y = not(A) or not(1) => Y = not (A) or '0'

                                                           Y = not (A) ----> inverter

Q.2) Implement inverter using only NOR gate.

Answer)  NOR Expression: Y = not(A) and not(B)

                When both inputs => '0' , output => '1'

                When both inputs => '1' , output => '0'

                Another Implementation:

                NOR Expression : Y = not(A) and not(B)

                If B => '0'

                Y = not(A) and not(0)

                Y = not(A) and '1'

                Y = not(A) ---> inverter

Inverter using NOR gate

                           

Q.3) Implement inverter using 2-to-1 multiplexer.

Answer) Multiplexer Equation :
               Out = S1.S + S0.not(S)
                If S1 => '0' ; S0 => '1'
                Out = 0.(S) + 1.not(S),
                Out=  not(S) ---> inverter

Inverter using multiplexer

Q.4) Implement AND gate using 2-to-1 multiplexer.               

Answer) Multiplexer Equation :                     
               Out = S1.S + S0.not(S)
                If S0 => '0'
                Out = S1.S
                   S1 => 'A'
                Out = A.S    ---> AND gate

AND gate using multiplexer

Q.5) Implement NAND gate using 2-to-1 multiplexer.

Answer) Multiplexer Equation :
               Out = S1.S + S0.not (S)
               S0 => '1';
               S1 => not(A);
               Out = not(A).S + not(S)   ---> NAND gate
               Simplifying it further,
               Out = (not(S) + S)(not(A) + not(S))
               Out = 1.(not(A) + not(S))
               Out = not(A) + not(S)   ----> NAND gate
             

NAND gate using multiplexer