Adders and Subtractors in Digital Logic: Circuits, Worked Examples and Exam Traps

Learn adders and subtractors from one-bit truth tables to four-bit ripple circuits, with verified addition, subtraction, overflow and delay examples.

KnowledgeGate Team

Exam prep & CS education

Updated 26 Aug 20266 min read

A one-bit adder or subtractor is easy to memorise. Multi-bit questions reveal whether you can track carry, borrow and overflow as different signals. Four-bit ripple circuits produce 1011 + 0110 = 10001 and 1001 - 0110 = 0011, while one controlled circuit performs both operations. Start at the LSB, label each signal, and check the assembled bits in decimal.

Related reading: carry lookahead MCQs and Boolean algebra and K-maps.

Adders and subtractors are combinational arithmetic circuits

An adder maps operand bits plus optional Cin to S and Cout. A subtractor maps operand bits plus optional Bin to D and Bout. Current inputs determine outputs, so these are combinational, not storage. CS Fundamentals is the subject route; Combinational Circuits in Digital Electronics guide places the same 1011 + 0110 ripple trace inside a broader design method. Borrow chains, controlled adder-subtraction and signed overflow extend that foundation.

A and B are operand bits. Cin and Cout denote carry; Bin and Bout denote borrow. Bit 0 is the LSB. A one-bit stage obeys:

  • A + B + Cin = S + 2Cout

  • A - B - Bin = D - 2Bout

These are arithmetic identities. In gate equations, + means Boolean OR.

Half adder and full adder: tables, equations and construction

Half adder:

A

B

S

C

0

0

0

0

0

1

1

0

1

0

1

0

1

1

0

1

Thus S = A XOR B and C = AB. Without Cin, it cannot serve as a non-LSB stage.

Full adder:

A

B

Cin

S

Cout

0

0

0

0

0

0

0

1

1

0

0

1

0

1

0

0

1

1

0

1

1

0

0

1

0

1

0

1

0

1

1

1

0

0

1

1

1

1

1

1

Equations are S = A XOR B XOR Cin and Cout = AB + Cin(A XOR B). The majority form is Cout = AB + ACin + BCin.

Construction uses two half adders and OR: HA1 gives P = A XOR B, C1 = AB; HA2 gives S = P XOR Cin, C2 = P Cin; then Cout = C1 + C2.

Four-bit ripple-carry addition worked bit by bit

Take A = 1011 (11), B = 0110 (6), C0 = 0. Start at bit 0.

Bit

Calculation

Result

0

1 + 0 + 0

S0 = 1, C1 = 0

1

1 + 1 + 0

S1 = 0, C2 = 1

2

0 + 1 + 1

S2 = 0, C3 = 1

3

1 + 0 + 1

S3 = 0, C4 = 1

Thus C4 S3 S2 S1 S0 = 10001; 11 + 6 = 17. Stored sum is 0001, with separate unsigned Cout = 1. Dropping it changes the value.

Carries are C1 = 0, C2 = 1, C3 = 1, C4 = 1. Each stage awaits the previous carry, so worst-case delay grows with stage count.

Four-bit ripple-carry adder chaining full adders FA0 to FA3 to compute 1011 plus 0110 equals 10001.

Half subtractor, full subtractor and a borrow chain

Half subtractor:

A

B

D

Borrow

0

0

0

0

0

1

1

1

1

0

1

0

1

1

0

0

Thus D = A XOR B, Borrow = NOT(A)B. Borrow occurs only for A = 0, B = 1.

A

B

Bin

D

Bout

0

0

0

0

0

0

0

1

1

1

0

1

0

1

1

0

1

1

0

1

1

0

0

1

0

1

0

1

0

0

1

1

0

0

0

1

1

1

1

1

For a full subtractor, D = A XOR B XOR Bin and Bout = NOT(A)B + NOT(A)Bin + B Bin. Equivalently, Bout = NOT(A)B + Bin NOT(A XOR B).

Calculate 1001 (9) minus 0110 (6), with b0 = 0; bi is the borrow entering bit i.

  • Bit 0: 1 - 0 - 0 gives D0 = 1, b1 = 0.

  • Bit 1: 0 - 1 - 0 gives D1 = 1, b2 = 1.

  • Bit 2: 0 - 1 - 1 = -2 gives D2 = 0, b3 = 1.

  • Bit 3: 1 - 0 - 1 gives D3 = 0, b4 = 0.

So D3D2D1D0 = 0011, matching 9 - 6 = 3. Carry and borrow move towards the MSB but remain distinct.

One adder-subtractor circuit performs both operations

For mode M, feed B'i = Bi XOR M and set C0 = M. Then M = 0 gives A + B; M = 1 gives A + NOT(B) + 1 = A - B in two's complement.

For A = 0100 (4) and B = 0011 (3):

  • M = 0: B' = 0011, C0 = 0, so 0100 + 0011 = 0111 (7), with Cout = 0.

  • M = 1: B' = 1100, C0 = 1, so 0100 + 1100 + 1 = 10001. Retain 0001 (1); leading 1 is Cout. Thus 4 - 3 = 1.

Mode complements B through XOR gates and supplies the added 1. In fixed-width signed arithmetic, discarded Cout alone does not indicate overflow.

Four-bit adder-subtractor using mode M and XOR gates on B to compute 0100 plus 0011 and 0100 minus 0011.

Carry, borrow, overflow and propagation delay differ

Cout reports carry beyond unsigned width. Final Bout = 1 reports unsigned underflow in a direct subtractor. Signed two's-complement overflow means an out-of-range signed result. A ripple adder uses carry into sign bit XOR carry out.

Four-bit signed 0111 (+7) plus 0011 (+3) leaves 1010. Here C3 = 1, C4 = 0, so V = C3 XOR C4 = 1; two positives appearing negative confirms overflow. The ripple addition's C4 = 1 matters for unsigned 11 + 6 = 17, but not alone for signed overflow.

Use the supplied model. At 2 ns per carry stage, four stages take 4 x 2 ns = 8 ns. With 1 ns final carry-to-sum delay, the MSB sum takes 3 x 2 + 1 = 7 ns. These are not hardware constants.

Exam traps and a repeatable solving routine

Trap

What goes wrong

Correction

Start at MSB

Signal direction is wrong

Start at bit 0

Give half adder Cin

That input is absent

Use a full adder

Use AB for subtractor borrow

Borrow direction reverses

Use NOT(A)B

Equate Cout and overflow

Unsigned and signed status mix

Test sign-bit carries

Complement B, omit 1

Subtraction is incomplete

Set C0 = 1

Read subtraction Cout as difference

A false fifth bit appears

Retain fixed-width bits

Questions may ask for a table row, equation, full stage from half stages, ripple trace, mode switch, status distinction or supplied delay.

Routine: identify width and representation, write the LSB input, trace every signal, assemble MSB to LSB, then check in decimal. KnowledgeGate offers over 40 practice questions on Adders & Subtractors. Use Combinational Circuits MCQs for practice and GATE Guidance by Sanchit Sir for structured preparation.

Adders and subtractors: the short version and next step

Remember: XOR gives sum or difference, AND gives half-adder carry, and NOT(A)B gives half-subtractor borrow. Full stages accept incoming signals; chaining creates word-level circuits.

Keep three anchors: 1011 + 0110 = 10001; 1001 - 0110 = 0011; controlled 0100 + 0011 = 0111 at M = 0, but 0100 - 0011 = 0001 at M = 1. Retrace signals, redraw the controlled circuit, and explain why M reaches the XOR bank and C0. Continue with Zero to Hero for a broader core-CS path.