Binary Addition #1 worksheet with exercises for adding 4-bit and 8-bit binary numbers.

Let's solve the binary addition problems step by step and explain the process.

---

Binary Addition Rules:

- 0 + 0 = 0
- 0 + 1 = 1
- 1 + 0 = 1
- 1 + 1 = 0, carry 1
- 1 + 1 + 1 = 1, carry 1

We'll go through each of the given problems.

---

## ✔ Left Side: 4-bit Binary Additions

1.

```
1 0 0 0
+ 0 0 1 0
---------
```

Start from right to left:

- 0 + 0 = 0
- 0 + 1 = 1
- 0 + 0 = 0
- 1 + 0 = 1

Result:
1 0 1 0

✔ Answer: `1010`

---

2.

```
0 0 1 0
+ 1 0 0 1
---------
```

- 0 + 1 = 1
- 1 + 0 = 1
- 0 + 0 = 0
- 0 + 1 = 1

Result:
1 0 1 1

✔ Answer: `1011`

---

3.

```
0 1 1 0
+ 0 1 0 1
---------
```

- 0 + 1 = 1
- 1 + 0 = 1
- 1 + 1 = 0, carry 1
- 0 + 0 + carry 1 = 1

So:
```
0 1 1 0
+ 0 1 0 1
---------
1 0 1 1
```

✔ Answer: `1011`

---

4.

```
0 0 1 0
+ 1 0 1 1
---------
```

- 0 + 1 = 1
- 1 + 1 = 0, carry 1
- 0 + 0 + carry 1 = 1
- 0 + 1 = 1

Result:
```
0 0 1 0
+ 1 0 1 1
---------
1 1 0 1
```

✔ Answer: `1101`

---

5.

```
0 1 1 0
+ 0 1 1 1
---------
```

- 0 + 1 = 1
- 1 + 1 = 0, carry 1
- 1 + 1 + carry 1 = 1, carry 1
- 0 + 0 + carry 1 = 1

So:
```
0 1 1 0
+ 0 1 1 1
---------
1 1 0 1
```

✔ Answer: `1101`

---

## ✔ Right Side: 8-bit Binary Additions

6.

```
0 1 0 0 1 0
+ 1 0 0 0 1 1
-------------
```

Align them:

```
0 1 0 0 1 0
+ 1 0 0 0 1 1
--------------
```

Add column by column (right to left):

- 0 + 1 = 1
- 1 + 1 = 0, carry 1
- 0 + 0 + carry 1 = 1
- 0 + 0 = 0
- 1 + 0 = 1
- 0 + 1 = 1

So:
```
0 1 0 0 1 0
+ 1 0 0 0 1 1
--------------
1 1 0 1 0 1
```

✔ Answer: `110101`

But wait — this is 6 bits, but we're adding two 6-bit numbers. Let's double-check:

Wait! The problem says "8 bit binary", but these numbers are only 6 bits long. Let's assume they're padded to 8 bits with leading zeros.

So rewrite as:

```
0 0 0 1 0 0 1 0 ← 010010 → 00010010
+ 0 0 1 0 0 0 1 1 ← 100011 → 00100011
-------------------
```

Now add:

```
0 0 0 1 0 0 1 0
+ 0 0 1 0 0 0 1 1
-----------------
0 0 1 1 0 1 0 1
```

Let’s do it step-by-step:

From right:
- 0 + 1 = 1
- 1 + 1 = 0, carry 1
- 0 + 0 + carry 1 = 1
- 0 + 0 = 0
- 1 + 0 = 1
- 0 + 0 = 0
- 0 + 1 = 1
- 0 + 0 = 0

Result: `0 0 1 1 0 1 0 1` → 00110101

✔ Answer: `00110101` (or just `110101` if leading zeros omitted)

---

7.

```
0 0 1 1
+ 1 0 1 1
--------
```

This is a 4-bit addition.

```
0 0 1 1
+ 1 0 1 1
--------
```

- 1 + 1 = 0, carry 1
- 1 + 1 + carry 1 = 1, carry 1
- 0 + 0 + carry 1 = 1
- 0 + 1 = 1

Result:
```
0 0 1 1
+ 1 0 1 1
--------
1 1 1 0
```

✔ Answer: `1110`

---

8.

```
1 1 1 1 1 0
+ 1 0 0 1 1 0
------------
```

These are 6-bit numbers. Let's assume 8-bit padding:

```
0 0 1 1 1 1 1 0
+ 0 0 1 0 0 1 1 0
------------------
```

Add:

```
0 0 1 1 1 1 1 0
+ 0 0 1 0 0 1 1 0
------------------
```

Column by column (right to left):

- 0 + 0 = 0
- 1 + 1 = 0, carry 1
- 1 + 1 + carry 1 = 1, carry 1
- 1 + 0 + carry 1 = 0, carry 1
- 1 + 0 + carry 1 = 0, carry 1
- 1 + 0 + carry 1 = 0, carry 1
- 0 + 1 + carry 1 = 0, carry 1
- 0 + 0 + carry 1 = 1

So result:
```
0 0 1 1 1 1 1 0
+ 0 0 1 0 0 1 1 0
------------------
0 1 1 0 0 1 0 0
```

Wait — let's write it clearly:

Final sum: `01100100`

But let's verify:

Actually, better to compute directly:

```
1 1 1 1 1 0
+ 1 0 0 1 1 0
--------------
```

Right to left:

- 0 + 0 = 0
- 1 + 1 = 0, carry 1
- 1 + 1 + carry 1 = 1, carry 1
- 1 + 0 + carry 1 = 0, carry 1
- 1 + 0 + carry 1 = 0, carry 1
- 1 + 1 + carry 1 = 1, carry 1 → now we have a carry out

So total: `1 0 1 0 0 1 0 0`? Wait, we had 6 bits, but carry over?

Wait — let's recompute carefully:

Number 1: `111110` = 62 in decimal
Number 2: `100110` = 38 in decimal
Sum: 62 + 38 = 100

Now convert 100 to binary: `1100100` → 7 bits

But our inputs were 6 bits, so maximum is 63, and 62 + 38 = 100 > 63 → overflow!

So when adding two 6-bit numbers, we get a 7-bit result.

But the question asks for 8-bit addition.

So pad both to 8 bits:

```
0 0 1 1 1 1 1 0 ← 62
+ 0 0 1 0 0 1 1 0 ← 38
------------------
0 1 1 0 0 1 0 0 ← 96? Wait, that's wrong.
```

Wait — 62 + 38 = 100

Convert 100 to binary:
100 ÷ 2 = 50 r0
50 ÷ 2 = 25 r0
25 ÷ 2 = 12 r1
12 ÷ 2 = 6 r0
6 ÷ 2 = 3 r0
3 ÷ 2 = 1 r1
1 ÷ 2 = 0 r1

So: `1100100` → 7 bits → `01100100` in 8 bits

So correct sum is `01100100`? No — `1100100` is 7 bits, so 8-bit is `01100100` → that's 96? No.

Wait — let's do binary addition properly.

```
0 0 1 1 1 1 1 0 ← 62
+ 0 0 1 0 0 1 1 0 ← 38
---------------------
```

Add column by column (from right):

- Col 0: 0 + 0 = 0
- Col 1: 1 + 1 = 0, carry 1
- Col 2: 1 + 1 + carry 1 = 1, carry 1
- Col 3: 1 + 0 + carry 1 = 0, carry 1
- Col 4: 1 + 0 + carry 1 = 0, carry 1
- Col 5: 1 + 1 + carry 1 = 1, carry 1
- Col 6: 0 + 0 + carry 1 = 1
- Col 7: 0 + 0 = 0

So result: `0 1 1 0 0 1 0 0` → 01100100

But 01100100 = 96? But 62 + 38 = 100.

Wait — error here.

Wait: let's check:

`00111110` = 62?
Let's compute:
32 + 16 + 8 + 4 + 2 = 62 → yes

`00100110` = 32 + 4 + 2 = 38 → yes

Sum: 62 + 38 = 100

Now 100 in binary:

- 64 + 32 = 96 → remainder 4 → 64 + 32 + 4 = 100
- So: 1100100 → 7 bits → `01100100`? No — 1100100 is 7 bits: positions 6 to 0

So 8-bit: `01100100` → but that's 96, not 100.

Wait — 1100100 = 64 + 32 + 4 = 100 → yes.

So 8-bit: `01100100` → no — 1100100 has 7 digits → 8-bit should be `01100100`?

Wait: 1100100 → 7 bits → to make 8-bit: `01100100` → but that's 0*128 + 1*64 + 1*32 + 0*16 + 0*8 + 1*4 + 0*2 + 0*1 = 64 + 32 + 4 = 100 → yes.

So `01100100` is correct.

But earlier calculation gave us:

```
Col 7: 0 + 0 = 0
Col 6: 0 + 0 + carry = 1
Col 5: 1 + 1 + carry = 1, carry 1
...
```

Wait — let's redo step by step:

```
0 0 1 1 1 1 1 0
+ 0 0 1 0 0 1 1 0
--------------------
```

Columns (right to left, index 0 to 7):

- Col 0: 0 + 0 = 0 → 0
- Col 1: 1 + 1 = 0, carry 1
- Col 2: 1 + 1 + carry 1 = 1, carry 1
- Col 3: 1 + 0 + carry 1 = 0, carry 1
- Col 4: 1 + 0 + carry 1 = 0, carry 1
- Col 5: 1 + 1 + carry 1 = 1, carry 1
- Col 6: 0 + 0 + carry 1 = 1
- Col 7: 0 + 0 = 0

So result: `0 1 1 0 0 1 0 0` → `01100100` → 100 → correct.

✔ Answer: `01100100`

---

What problem have you encountered? Why has this happened?

The last question is:
> What problem have you encountered with the 8-bit additions? Why has this happened?

Looking at the 8-bit additions, especially the one with:

```
1 1 1 1 1 0
+ 1 0 0 1 1 0
```

We saw that the sum is `1100100`, which is 7 bits, but we’re using 8-bit representation. However, the sum exceeds the maximum value representable in 6 bits, but since we're using 8 bits, it's fine.

But perhaps the issue is overflow?

Wait — the problem might be referring to carry-out or overflow when adding two 8-bit numbers.

But in this case, all sums fit within 8 bits.

Wait — look at this addition:

```
1 1 1 1 1 0
+ 1 0 0 1 1 0
```

But if these were 6-bit numbers, then:

Max 6-bit number: `111111` = 63
Here: 62 + 38 = 100 > 63 → overflow

So if we were storing the result in a 6-bit register, we’d lose the higher bits → overflow.

But since we're doing 8-bit addition, we can represent up to 255, so 100 fits.

So the problem might be:

> When adding two 6-bit numbers (like 62 and 38), their sum (100) requires more than 6 bits → overflow if stored in 6-bit format.

But the question says "add together the following 8 bit binary" — but the numbers shown are only 6 bits.

So likely, the problem is:

> We have insufficient bits to represent the sum of two large numbers. For example, adding two 6-bit numbers may produce a 7-bit result, which cannot be stored in a 6-bit system, causing overflow.

Even though we're doing 8-bit addition, if the original numbers were intended to be 6-bit, then overflow occurs if we try to store the result in a 6-bit field.

But since we're using 8 bits, it's okay.

So the encountered problem is:

> Overflow — when the sum of two numbers exceeds the maximum value that can be represented in the given number of bits.

For example, in 6-bit unsigned binary, max is 63. Adding 62 + 38 = 100 > 63 → overflow.

Even though we used 8-bit arithmetic to avoid it, the issue arises when limited to fewer bits.

---

## ✔ Final Answers Summary:

4-bit Additions:

1. `1000 + 0010 = 1010`
2. `0010 + 1001 = 1011`
3. `0110 + 0101 = 1011`
4. `0010 + 1011 = 1101`
5. `0110 + 0111 = 1101`

8-bit Additions:

6. `010010 + 100011 = 110101` → `00110101` (8-bit)
7. `0011 + 1011 = 1110`
8. `111110 + 100110 = 1100100` → `01100100` (8-bit)

---

❓ Problem Encountered?

> Overflow occurs when the sum of two binary numbers exceeds the maximum value representable in the given number of bits.

For example, adding two 6-bit numbers like `111110` (62) and `100110` (38) gives 100, which requires 7 bits. If we only have 6 bits to store the result, the extra bit is lost → overflow.

This happens because the result exceeds the range of the data type.

---

✔ Conclusion:

- Binary addition follows carry rules.
- Overflow is a key issue in digital systems.
- Always ensure enough bits are available to hold the sum.

Let me know if you'd like the answers boxed or formatted differently!