Genetics practice worksheet with Punnett squares for determining offspring genotypes.

Let's solve the Punnett Square Exercises step by step. The goal is to fill in the missing alleles (genes) in each Punnett square based on the given information.

---

🔍 Understanding the Rules:

- Uppercase letters (e.g., B, E) = Dominant allele
- Lowercase letters (e.g., b, e) = Recessive allele
- In a genotype:
- Hybrid (heterozygous) = uppercase first (e.g., Bb)
- Purebred (homozygous) = both same (BB or bb)
- For parents: dominant allele listed first if present.
- Each box in the grid represents a possible offspring genotype.

We’ll go through each square and fill in the missing parts.

---

✔ Step-by-step Solutions

#### 1.
```
B | B
b | |
```
- Parent 1: BB → gives B and B
- Parent 2: b → must be bb, so gives b and b
- Offspring: Bb, Bb, Bb, Bb → all Bb
- Fill in:
```
B | B
b | Bb | Bb
b | Bb | Bb
```

#### 2.
```
B | B
B | |
```
- Parent 1: BB → B, B
- Parent 2: B → must be BB → B, B
- Offspring: BB, BB, BB, BB
```
B | B
B | BB | BB
B | BB | BB
```

#### 3.
```
B | b
b | |
```
- Parent 1: Bb → B, b
- Parent 2: b → must be bb → b, b
- Offspring: Bb, bb, Bb, bb
```
B | b
b | Bb | bb
b | Bb | bb
```

#### 4.
```
B | b
b | |
```
- Same as #3? Wait — parent 1 is Bb → B and b
- Parent 2 is b → but only one allele shown → must be bb
- So:
```
B | b
b | Bb | bb
b | Bb | bb
```

Wait — this is identical to #3. But let’s check:

Actually, this is likely meant to be:
- Parent 1: Bb → B, b
- Parent 2: Bb → B, b

But here it shows only one b from second parent → maybe it's Bb?

But the top row has B and b → so parent 1 is Bb
Bottom row has b and blank → so parent 2 is Bb → gives B and b

So:
```
B | b
b | Bb | bb
B | BB | Bb
```

But wait — bottom row starts with "b" then blank → so second parent is Bb → alleles: B and b

So:
```
B | b
b | Bb | bb
B | BB | Bb
```

Yes! So corrected:
```
B | b
b | Bb | bb
B | BB | Bb
```

#### 5.
```
b | B
b | |
```
- Parent 1: b and B → Bb
- Parent 2: b and b → bb
- Offspring:
```
b | B
b | bb | Bb
b | bb | Bb
```

#### 6.
```
b | b
b | |
```
- Parent 1: bb → b, b
- Parent 2: b → must be bb → b, b
- All offspring: bb
```
b | b
b | bb | bb
b | bb | bb
```

#### 7.
```
E | e
e | |
```
- Parent 1: Ee → E, e
- Parent 2: e → must be ee → e, e
- Offspring: Ee, ee, Ee, ee
```
E | e
e | Ee | ee
e | Ee | ee
```

#### 8.
```
A | a
A | |
```
- Parent 1: Aa → A, a
- Parent 2: A → must be AA → A, A
- Offspring: AA, Aa, AA, Aa
```
A | a
A | AA | Aa
A | AA | Aa
```

#### 9.
```
D | d
d | |
```
- Parent 1: Dd → D, d
- Parent 2: d → must be dd → d, d
- Offspring: Dd, dd, Dd, dd
```
D | d
d | Dd | dd
d | Dd | dd
```

#### 10.
```
H | H
h | |
```
- Parent 1: HH → H, H
- Parent 2: h → must be hh → h, h
- Offspring: Hh, Hh, Hh, Hh
```
H | H
h | Hh | Hh
h | Hh | Hh
```

#### 11.
```
B |
B | Bb
b | |
```
- Offspring includes Bb → so one parent gives B, other gives b
- Top parent: B and ? → one B already used → must be Bb → B and b
- Bottom parent: B and b → gives B and b
- But offspring: Bb appears twice → need to determine alleles

Wait — top row: B and blank → so parent 1: B and ?
Bottom row: B and b → parent 2: B and b → so Bb

Offspring:
- First column: B (from top) + B (from bottom) = BB
- Second column: B (top) + b (bottom) = Bb
- Third row: b (top) + B = Bb
- Fourth: b + b = bb

But we have:
```
B | ?
B | Bb
b | |
```

Wait — actually, the format is:
```
B | ?
B | Bb
b | |
```

So:
- Parent 1 (top): B and ? → must be B and b → Bb
- Parent 2 (left): B and b → Bb

So full square:
```
B | b
B | BB | Bb
b | Bb | bb
```

But in the image, the second column of first row is blank → should be Bb

And second row, first column is Bb → already filled

So fill in:
```
B | b
B | BB | Bb
b | Bb | bb
```

#### 12.
```
B |
b | Bb
B | |
```

Top row: B and ? → parent 1: B and ?
Left column: b and B → parent 2: B and b → Bb

Offspring:
- First cell: B (top) + b (left) = Bb → already given
- Second cell: ? + B = ?
- Third: b + B = Bb → already given
- Fourth: ? + b = ?

But top row: B and ? → if parent 1 is Bb, then alleles are B and b

So:
```
B | b
b | Bb | bb
B | BB | Bb
```

But in the image:
```
B |
b | Bb
B | |
```

So:
- Parent 1: B and b → Bb
- Parent 2: b and B → Bb

Then:
```
B | b
b | Bb | bb
B | BB | Bb
```

So fill in:
- Top right: b
- Bottom left: BB
- Bottom right: Bb

#### 13.
```
B |
B | Bb
b | |
```

Top: B and ? → parent 1: B and ?
Left: B and b → parent 2: B and b → Bb

Offspring:
- B + B = BB
- B + b = Bb
- b + B = Bb
- b + b = bb

But given:
- First row, second column: Bb → so second allele from parent 1 must be b → parent 1: Bb

So:
```
B | b
B | BB | Bb
b | Bb | bb
```

Fill in:
- Top right: b
- Bottom left: Bb
- Bottom right: bb

#### 14.
```
d |
D | Dd
d | |
```

Parent 1: d and ? → must be Dd → D and d
Parent 2: D and d → Dd

So:
```
D | d
D | DD | Dd
d | Dd | dd
```

Given:
- Dd in first row, second column → correct
- So fill in:
- Top right: d
- Bottom left: Dd
- Bottom right: dd

#### 15.
```
N | n
Nn | nn
```

This is messy. Let's interpret:

It says:
```
N | n
Nn | nn
```

Wait — probably:
- Top row: N and n → parent 1: Nn
- Left column: Nn and nn → so parent 2: Nn and nn → no, can't be both

Wait — looks like two rows:
- Row 1: N and n → so parent 1: N and n → Nn
- Row 2: Nn and nn → that’s not standard

Wait — perhaps it’s:
```
N | n
Nn | |
nn | |
```

No — better interpretation:

Looking at the layout:
```
N | n
Nn | nn
```

Ah — it’s:
- Parent 1: N and n → Nn
- Parent 2: Nn and nn → but that’s impossible

Wait — perhaps the left side is the parent: Nn and nn → but that’s two parents?

No — likely:
- Top row: N and n → parent 1: Nn
- Left column: Nn and nn → parent 2: Nn and nn? No.

Wait — this might be a typo. Let's look at the structure:

The square is:
```
N | n
Nn | |
nn | |
```

So:
- Parent 1: N and n → Nn
- Parent 2: Nn and nn → no, that doesn’t make sense.

Wait — perhaps it's:
- Parent 1: N and n → Nn
- Parent 2: N and n → Nn

But the left column shows "Nn" and "nn"? That can't be.

Alternatively, perhaps:
- The left side is Nn and nn, meaning the second parent is Nn and nn — impossible.

Wait — perhaps it's:
- Parent 1: N and n → Nn
- Parent 2: N and n → Nn

Then offspring:
```
N | n
N | NN | Nn
n | Nn | nn
```

But the image says:
```
N | n
Nn | nn
```

Maybe the left column is Nn and nn, which means:
- Parent 2: Nn and nn → but that’s two genotypes?

Wait — perhaps the offspring are given: Nn and nn

But there are two rows: Nn and nn → so maybe:
- One offspring is Nn, one is nn

But in a Punnett square, we have four boxes.

Perhaps it's:
- Parent 1: N and n → Nn
- Parent 2: n and n → nn

Then:
```
N | n
n | Nn | nn
n | Nn | nn
```

Yes! That makes sense.

So:
- Parent 1: Nn → N and n
- Parent 2: nn → n and n
- Offspring: Nn, nn, Nn, nn

So fill in:
```
N | n
n | Nn | nn
n | Nn | nn
```

So:
- Top row: N and n
- Left column: n and n
- Boxes: Nn, nn, Nn, nn

#### 16.
```
E |
Ee | Ee
```

Same issue.

Likely:
- Parent 1: E and ? → must be Ee → E and e
- Parent 2: Ee and Ee → so both parents are Ee

Then:
```
E | e
E | EE | Ee
e | Ee | ee
```

But the image shows:
```
E |
Ee | Ee
```

Probably:
- Parent 1: E and e → Ee
- Parent 2: E and e → Ee

So:
```
E | e
E | EE | Ee
e | Ee | ee
```

So fill in:
- Top right: e
- Bottom left: Ee
- Bottom right: ee

#### 17.
```
R | Rr
rr |
```

Likely:
- Parent 1: R and r → Rr
- Parent 2: r and r → rr

Then:
```
R | r
r | Rr | rr
r | Rr | rr
```

So fill in:
- Top right: r
- Bottom left: Rr
- Bottom right: rr

#### 18.
```
F | Ff
FF |
```

Parent 1: F and f → Ff
Parent 2: F and F → FF

Then:
```
F | f
F | FF | Ff
F | FF | Ff
```

So:
- Top right: f
- Bottom left: FF
- Bottom right: Ff

#### 19.
```
B | B
Bb | Bb
```

Parent 1: B and B → BB
Parent 2: B and b → Bb

Then:
```
B | B
B | BB | BB
b | Bb | Bb
```

So:
- Top row: B and B
- Left column: B and b
- Boxes: BB, BB, Bb, Bb

But the image shows:
```
B | B
Bb | Bb
```

So:
- First row: B and B → BB and BB
- Second row: B and B → Bb and Bb → so second parent gives B and b → Bb

So yes:
```
B | B
B | BB | BB
b | Bb | Bb
```

#### 20.
```
tt |
Tt | ee
```

Wait — this is confusing.

Look at:
```
|
tt |
Tt | ee
```

Possibly:
- Parent 1: t and t → tt
- Parent 2: T and t → Tt

Then:
```
t | t
T | Tt | Tt
t | tt | tt
```

But offspring include ee? No — that’s different gene.

Wait — the trait changes.

This is two different traits?

But the exercise is for single traits.

Wait — the last few squares may be for different genes.

Let’s look carefully.

#### 20.
```
|
tt |
Tt | ee
```

Wait — possibly:
- Parent 1: t and t → tt
- Parent 2: T and t → Tt

Then offspring:
```
t | t
T | Tt | Tt
t | tt | tt
```

But the image shows:
- First row: tt (offspring?)
- Second row: Tt and ee

No — likely a typo in formatting.

Wait — perhaps:
- Parent 1: t and t → tt
- Parent 2: T and t → Tt

Then:
```
t | t
T | Tt | Tt
t | tt | tt
```

So fill in:
- Top row: t and t
- Left column: T and t
- Boxes: Tt, Tt, tt, tt

But the image says:
```
|
tt |
Tt | ee
```

Hmm — maybe it's:
- Parent 1: t and t → tt
- Parent 2: T and t → Tt

But the offspring are listed as tt and Tt — so it's okay.

But “ee” appears — that’s a different gene.

Wait — perhaps the last few are for different genes.

Let’s skip and come back.

#### 21.
```
N |
N | Nn
n | |
```

Parent 1: N and ? → must be Nn → N and n
Parent 2: N and n → Nn

So:
```
N | n
N | NN | Nn
n | Nn | nn
```

So fill in:
- Top right: n
- Bottom left: Nn
- Bottom right: nn

#### 22.
```
B | B
b | Bb
B | |
```

Parent 1: B and B → BB
Parent 2: b and B → Bb

Then:
```
B | B
b | Bb | Bb
B | BB | BB
```

So:
- Top row: B and B
- Left column: b and B
- Boxes: Bb, Bb, BB, BB

#### 23.
```
d | d
D | Dd
d | |
```

Parent 1: d and d → dd
Parent 2: D and d → Dd

Then:
```
d | d
D | Dd | dd
d | dd | dd
```

So:
- Top row: d and d
- Left column: D and d
- Boxes: Dd, dd, dd, dd

#### 24.
```
D | d
d | Dd
d | dd
```

Parent 1: D and d → Dd
Parent 2: d and d → dd

Then:
```
D | d
d | Dd | dd
d | Dd | dd
```

So:
- Top row: D and d
- Left column: d and d
- Boxes: Dd, dd, Dd, dd

#### 25.
```
Ee | Ee
ee |
```

Parent 1: E and e → Ee
Parent 2: e and e → ee

Then:
```
E | e
e | Ee | ee
e | Ee | ee
```

So:
- Top row: E and e
- Left column: e and e
- Boxes: Ee, ee, Ee, ee

#### 26.
```
Bb | Bb
Bb |
```

Parent 1: B and b → Bb
Parent 2: B and b → Bb

Then:
```
B | b
B | BB | Bb
b | Bb | bb
```

So:
- Top row: B and b
- Left column: B and b
- Boxes: BB, Bb, Bb, bb

#### 27.
```
Bb | Bb
Bb |
```

Same as above — just repeated?

Wait — maybe it's:
- Parent 1: B and b → Bb
- Parent 2: B and b → Bb

So same as #26

#### 28.
```
bb |
Bb | Bb
```

Parent 1: b and b → bb
Parent 2: B and b → Bb

Then:
```
b | b
B | Bb | Bb
b | bb | bb
```

So:
- Top row: b and b
- Left column: B and b
- Boxes: Bb, Bb, bb, bb

#### 29.
```
Bb | Bb
bb |
```

Parent 1: B and b → Bb
Parent 2: b and b → bb

Then:
```
B | b
b | Bb | bb
b | Bb | bb
```

So:
- Top row: B and b
- Left column: b and b
- Boxes: Bb, bb, Bb, bb

---

✔ Final Answer Summary:

Here are the completed Punnett squares:

1.
```
B | B
b | Bb | Bb
b | Bb | Bb
```

2.
```
B | B
B | BB | BB
B | BB | BB
```

3.
```
B | b
b | Bb | bb
b | Bb | bb
```

4.
```
B | b
b | Bb | bb
B | BB | Bb
```

5.
```
b | B
b | bb | Bb
b | bb | Bb
```

6.
```
b | b
b | bb | bb
b | bb | bb
```

7.
```
E | e
e | Ee | ee
e | Ee | ee
```

8.
```
A | a
A | AA | Aa
A | AA | Aa
```

9.
```
D | d
d | Dd | dd
d | Dd | dd
```

10.
```
H | H
h | Hh | Hh
h | Hh | Hh
```

11.
```
B | b
B | BB | Bb
b | Bb | bb
```

12.
```
B | b
b | Bb | bb
B | BB | Bb
```

13.
```
B | b
B | BB | Bb
b | Bb | bb
```

14.
```
D | d
D | DD | Dd
d | Dd | dd
```

15.
```
N | n
n | Nn | nn
n | Nn | nn
```

16.
```
E | e
E | EE | Ee
e | Ee | ee
```

17.
```
R | r
r | Rr | rr
r | Rr | rr
```

18.
```
F | f
F | FF | Ff
F | FF | Ff
```

19.
```
B | B
B | BB | BB
b | Bb | Bb
```

20.
```
t | t
T | Tt | Tt
t | tt | tt
```

21.
```
N | n
N | NN | Nn
n | Nn | nn
```

22.
```
B | B
b | Bb | Bb
B | BB | BB
```

23.
```
d | d
D | Dd | dd
d | dd | dd
```

24.
```
D | d
d | Dd | dd
d | Dd | dd
```

25.
```
E | e
e | Ee | ee
e | Ee | ee
```

26.
```
B | b
B | BB | Bb
b | Bb | bb
```

27.
Same as 26

28.
```
b | b
B | Bb | Bb
b | bb | bb
```

29.
```
B | b
b | Bb | bb
b | Bb | bb
```

---

📝 Explanation:

Each Punnett square follows the rules:
- Parents’ genotypes determine the alleles they pass.
- Each parent contributes one allele per gene.
- Offspring genotypes are combinations of one allele from each parent.
- Dominant alleles (uppercase) mask recessive ones (lowercase).
- Hybrid genotypes list dominant first (e.g., Bb).

This practice helps predict genetic outcomes in monohybrid crosses.

Let me know if you'd like a printable version or explanation for any specific square!