Kami Export - Darrin Greaves - restriction enzyme worksheet 2022 ... - Free Printable

Let’s solve this step by step.

We’re given a DNA sequence and told that it has two mutations: one is an insertion (INS) and one is a deletion (DEL). We need to figure out what the original, unmutated DNA sequence was before these changes happened.

Here’s the mutated sequence we’re given:

TACCGG AATTGGCTCGTTATGTGAGTC

And we’re told:
- There’s an insertion of “A” at position 7 (counting from left, starting at 1).
- There’s a deletion of “C” at position 20.

That means:
→ The “A” at position 7 was *added* — so in the original sequence, that “A” wasn’t there.
→ The “C” at position 20 was *removed* — so in the original sequence, that “C” *was* there.

So to get back to the original sequence, we need to:
1. Remove the inserted “A” at position 7.
2. Add back the deleted “C” at position 20.

But wait — when we remove the “A” at position 7, all the letters after it shift left by one. So the position numbers change! That means we can’t just add the “C” back at position 20 in the current sequence — because after removing the “A”, the positions are different.

So let’s do this carefully.

---

Step 1: Start with the mutated sequence:

Position: 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25
Sequence: T A C C G G A A T T G G C T C G T T A T G T G A G T C

Wait — actually, let me count again. The full sequence is:

TACCGG AATTGGCTCGTTATGTGAGTC

Let’s write it without spaces:

T A C C G G A A T T G G C T C G T T A T G T G A G T C

Now count each letter:

1:T, 2:A, 3:C, 4:C, 5:G, 6:G, 7:A, 8:A, 9:T, 10:T, 11:G, 12:G, 13:C, 14:T, 15:C, 16:G, 17:T, 18:T, 19:A, 20:T, 21:G, 22:T, 23:G, 24:A, 25:G, 26:T, 27:C

Wait — that’s 27 bases? But the problem says the mutation is at position 20. Let me check the original image text again.

Actually, looking back at the user’s input, the sequence is written as:

“TACCGG AATTGGCTCGTTATGTGAGTC”

If we remove the space, it’s:

TACCGGAATTGGCTCGTTATGTGAGTC → that’s 27 characters.

But the problem says:

> Insertion of “A” at position 7
> Deletion of “C” at position 20

So let’s assume the sequence is indexed starting at 1, and we’ll work with the string as given.

Original mutated sequence (with space removed for counting):

Index: 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27
Base: T A C C G G A A T T G G C T C G T T A T G T G A G T C

So:
- Position 7 = A → this is the inserted base → remove it.
- Position 20 = T → but the problem says deletion of “C” at position 20. Wait — that doesn’t match.

Hold on — maybe I miscounted.

Let me write the sequence exactly as given in the problem:

“TACCGG AATTGGCTCGTTATGTGAGTC”

Perhaps the space is part of the formatting, not the sequence. Let’s ignore the space and treat it as one continuous string:

TACCGGAATTGGCTCGTTATGTGAGTC

Let’s break it into groups to count easier:

TAC CGG AAT TGG CTC GTT ATG TGA GTC → that’s 9 groups of 3 = 27 bases.

Positions:

1:T, 2:A, 3:C,
4:C, 5:G, 6:G,
7:A, 8:A, 9:T,
10:T, 11:G, 12:G,
13:C, 14:T, 15:C,
16:G, 17:T, 18:T,
19:A, 20:T, 21:G,
22:T, 23:G, 24:A,
25:G, 26:T, 27:C

So position 7 is A → correct, that’s the insertion.

Position 20 is T — but the problem says deletion of “C” at position 20. That’s a problem.

Wait — perhaps the deletion is of a “C” that was originally at position 20, but now due to the insertion, it’s shifted?

No — the problem states:

> The following diagram shows the result of two mutations...
> - Insertion of “A” at position 7
> - Deletion of “C” at position 20

This likely means: in the *mutated* sequence, if you look at position 7, there’s an extra “A” that wasn’t there before; and at position 20, a “C” is missing compared to the original.

But in our current sequence, position 20 is “T”, not “C”. So maybe the “C” that was deleted is not at position 20 in the mutated sequence, but rather, the deletion occurred at position 20 in the *original* sequence?

The problem says: “Deletion of ‘C’ at position 20” — it doesn’t specify whether it’s position in original or mutated. But typically, when we say “mutation at position X”, we mean in the mutated sequence, unless specified otherwise.

But here’s the key: the diagram in the image (which we can’t see, but the text describes) probably shows arrows pointing to where the mutations are.

Looking back at the user’s text:

It says:

> TACCGG AATTGGCTCGTTATGTGAGTC
> ↑ ↑
> INS DEL

With “INS” under position 7 (the first A after GG), and “DEL” under position 20.

In the sequence “TACCGG AATTGGCTCGTTATGTGAGTC”, if we number including the space? No, spaces aren’t part of DNA.

Perhaps the sequence is meant to be read as:

Positions 1-6: TACCGG
Then position 7: A (inserted)
Then the rest: ATTGGCTCGTTATGTGAGTC

But then total length would be 6 + 1 + 21 = 28? Not matching.

Another idea: maybe the “position 20” refers to the position in the original sequence before any mutations.

Let’s think differently.

Suppose the original sequence had no mutations. Then someone inserted an “A” at position 7, and deleted a “C” at position 20 (in the original numbering).

After insertion at 7, all positions from 7 onward shift right by 1.

Then, deletion at position 20 (original) — but after insertion, that position is now 21.

This is getting messy.

Let’s use the standard approach for reversing mutations.

To reverse an insertion: remove the inserted base.

To reverse a deletion: insert the deleted base back at the correct position.

But we need to know the order of mutations. The problem doesn’t specify which happened first. Usually, we assume they are independent, but for reconstruction, we need to undo them in reverse order.

Assume the mutations happened in the order: first deletion, then insertion? Or vice versa?

The problem doesn’t say. But in such problems, often we consider the net effect.

Perhaps the simplest way is:

Start with the mutated sequence.

Remove the inserted “A” at position 7.

Then, since a “C” was deleted at position 20 (in the original sequence), but after removing the “A”, the positions have changed, so we need to find where position 20 was in the original.

Let’s define:

Let O = original sequence.

After inserting “A” at position 7 in O, we get a new sequence M1.

Then, deleting “C” at position 20 in M1? Or in O?

The problem says: “Insertion of ‘A’ at position 7” and “Deletion of ‘C’ at position 20” — likely both refer to positions in the final mutated sequence.

But in the final mutated sequence, position 7 is “A” (inserted), and position 20 is “T”, but it should be “C” if it was deleted? That doesn't make sense.

Unless "deletion of 'C' at position 20" means that in the original sequence, there was a "C" at position 20, and it was deleted, so in the mutated sequence, position 20 is whatever came after.

Let's try this interpretation:

- In the original sequence, at position 7, there was some base, but an "A" was inserted before it or after it? Typically, "insertion at position 7" means between position 6 and 7, so the new "A" becomes position 7, and old position 7 becomes 8, etc.

Similarly, "deletion at position 20" means the base that was at position 20 in the original is gone, so in the mutated sequence, position 20 is what was position 21 in original.

But then the mutated sequence has length = original length +1 (for insertion) -1 (for deletion) = same length as original.

Oh! That's important.

If you insert one base and delete one base, the total length remains the same.

So the mutated sequence has the same length as the original.

In our case, the given sequence is 27 bases long (TACCGGAATTGGCTCGTTATGTGAGTC).

So original was also 27 bases.

Now, to recover original:

- The "A" at position 7 in mutated sequence is the inserted one, so remove it. After removal, the sequence is 26 bases.

- But we need to add back the deleted "C". Where? At position 20 in the original sequence.

After removing the "A" at position 7, the bases from position 8 onward in mutated sequence become position 7 onward in the intermediate sequence.

So, in the intermediate sequence (after removing inserted "A"), the base that was at position 20 in mutated sequence is now at position 19 in intermediate.

But the deletion was of a "C" at position 20 in the original sequence.

After removing the inserted "A", the intermediate sequence corresponds to the original sequence except that the "C" at position 20 is missing.

So in the intermediate sequence, positions 1 to 19 are the same as original positions 1 to 19.

Position 20 in original is missing, so in intermediate, position 20 is what was original position 21, and so on.

Therefore, to get back to original, we need to insert a "C" at position 20 in the intermediate sequence.

Let's do it step by step.

Mutated sequence (27 bases):
1:T, 2:A, 3:C, 4:C, 5:G, 6:G, 7:A, 8:A, 9:T, 10:T, 11:G, 12:G, 13:C, 14:T, 15:C, 16:G, 17:T, 18:T, 19:A, 20:T, 21:G, 22:T, 23:G, 24:A, 25:G, 26:T, 27:C

Step 1: Remove the inserted "A" at position 7.

So remove base at index 7 (which is "A").

New sequence (26 bases):
1:T, 2:A, 3:C, 4:C, 5:G, 6:G, 7:A (was 8), 8:T (was 9), 9:T (was 10), 10:G (was 11), 11:G (was 12), 12:C (was 13), 13:T (was 14), 14:C (was 15), 15:G (was 16), 16:T (was 17), 17:T (was 18), 18:A (was 19), 19:T (was 20), 20:G (was 21), 21:T (was 22), 22:G (was 23), 23:A (was 24), 24:G (was 25), 25:T (was 26), 26:C (was 27)

So intermediate sequence: TACCGG ATTGGCTCGTTATGTGAGTC

Write it: TACCGGATTGGCTCGTTATGTGAGTC

Now, this intermediate sequence is missing the "C" that was deleted from position 20 of the original sequence.

That means, in the original sequence, at position 20, there was a "C", and it's not here.

In the intermediate sequence, positions 1 to 19 correspond to original positions 1 to 19.

Position 20 in intermediate corresponds to original position 21.

So to get original, we need to insert a "C" at position 20 in the intermediate sequence.

So take intermediate sequence: positions 1-19: TACCGGATTGGCTCGTTAT

Then insert "C" at position 20.

Then append the rest: from position 20 of intermediate onwards: TGTGAGTC

Intermediate sequence is 26 bases: indices 1 to 26.

After inserting "C" at position 20, the new sequence will have:

Bases 1-19: same as intermediate 1-19

Base 20: "C" (inserted)

Bases 21-27: intermediate bases 20-26

Intermediate bases 20-26: G,T,G,A,G,T,C (from earlier: pos20:G,21:T,22:G,23:A,24:G,25:T,26:C)

So original sequence:

1-19: T A C C G G A T T G G C T C G T T A T

20: C

21-27: G T G A G T C

So let's write it:

TACCGGATTGGCTCGTTAT C GTGAGTC

Combine: TACCGGATTGGCTCGTTATCGTGAGTC

Now, let's verify the length: 19 + 1 + 7 = 27 bases. Good.

Now, let's check if this makes sense with the mutations.

Original: TACCGGATTGGCTCGTTATCGTGAGTC

Apply insertion of "A" at position 7.

Position 7 in original: let's list original:

1:T,2:A,3:C,4:C,5:G,6:G,7:A,8:T,9:T,10:G,11:G,12:C,13:T,14:C,15:G,16:T,17:T,18:A,19:T,20:C,21:G,22:T,23:G,24:A,25:G,26:T,27:C

Insert "A" at position 7: so between 6 and 7, or at 7? Typically, "insert at position 7" means the new base becomes position 7, and old 7 becomes 8, etc.

So after insertion:

1:T,2:A,3:C,4:C,5:G,6:G,7:A (new),8:A (old7),9:T (old8),10:T (old9),11:G (old10),12:G (old11),13:C (old12),14:T (old13),15:C (old14),16:G (old15),17:T (old16),18:T (old17),19:A (old18),20:T (old19),21:C (old20),22:G (old21),23:T (old22),24:G (old23),25:A (old24),26:G (old25),27:T (old26),28:C (old27)

But this is 28 bases, and we haven't done the deletion yet.

Now, delete "C" at position 20.

In this sequence after insertion, position 20 is T (from above: pos20:T).

But we need to delete a "C". Position 21 is C.

Perhaps "at position 20" means in the original numbering, but after insertion, it's shifted.

The problem likely means that in the final mutated sequence, the deletion is observed at position 20, but since we inserted first, the position changed.

To avoid confusion, let's apply the mutations to our reconstructed original and see if we get the given mutated sequence.

Reconstructed original: TACCGGATTGGCTCGTTATCGTGAGTC

Now, perform the two mutations:

First, insertion of "A" at position 7.

Assume "at position 7" means after the 6th base, so insert between 6 and 7.

Original positions 1-6: TACCGG

Insert "A" → now we have TACCGG A ...

Then original 7-27: ATTGGCTCGTTATCGTGAGTC

So after insertion: TACCGGA ATTGGCTCGTTATCGTGAGTC → but this is 28 bases.

Now, delete "C" at position 20.

In this new sequence, what is position 20?

List:

1:T,2:A,3:C,4:C,5:G,6:G,7:A (inserted),8:A,9:T,10:T,11:G,12:G,13:C,14:T,15:C,16:G,17:T,18:T,19:A,20:T,21:C,22:G,23:T,24:G,25:A,26:G,27:T,28:C

So position 20 is T.

But we need to delete a "C". Position 21 is C.

Perhaps the deletion is of the "C" that was at position 20 in the original, which is now at position 21 after insertion.

So delete position 21.

After deletion, remove base at 21 (which is C).

New sequence: positions 1-20: TACCGGAATTGGCTCGTTAT

Then 21-27: G,T,G,A,G,T,C (from old 22-28)

So: TACCGGAATTGGCTCGTTAT GTGAGTC

Which is TACCGGAATTGGCTCGTTATGTGAGTC

Compare to given mutated sequence: TACCGG AATTGGCTCGTTATGTGAGTC

Yes! Exactly the same, if we ignore the space.

Given: TACCGG AATTGGCTCGTTATGTGAGTC → which is TACCGGAATTGGCTCGTTATGTGAGTC

Perfect match.

So the original sequence is TACCGGATTGGCTCGTTATCGTGAGTC

Now, to write it nicely.

Final Answer: TACCGGATTGGCTCGTTATCGTGAGTC