Repeated DNA Sequences - Practice Coding Problems

Repeated DNA Sequences - Problem

DNA Sequence Analysis Challenge

In molecular biology, DNA sequences are fundamental building blocks of life, composed of four nucleotides: 'A' (Adenine), 'C' (Cytosine), 'G' (Guanine), and 'T' (Thymine). Scientists often need to identify repetitive patterns in DNA sequences to understand genetic mutations, evolutionary relationships, and disease markers.

Your task is to analyze a DNA string and find all 10-letter sequences that appear more than once in the molecule. For example, in the sequence "ACGAATTCCGACGAATTCCG", the substring "ACGAATTCCG" appears twice.

Goal: Return all 10-character substrings that occur multiple times in the given DNA sequence. The order of results doesn't matter.

Input & Output

example_1.py — Basic Case

$ Input: s = "AAAAACCCCCAAAAACCCCCCAAAAAGGGTTT"

› Output: ["AAAAACCCCC", "CCCCCAAAAA"]

💡 Note: The 10-letter sequence "AAAAACCCCC" appears at positions 0 and 10. The sequence "CCCCCAAAAA" appears at positions 6 and 16. These are the only two sequences that repeat.

example_2.py — No Repeats

$ Input: s = "AAAAAAAAAA"

› Output: ["AAAAAAAAAA"]

💡 Note: The only possible 10-letter sequence is "AAAAAAAAAA" which appears once at position 0, but since the string has exactly 10 characters, this sequence actually appears only once. Wait - let me recalculate: this sequence appears at position 0 only, so it should return empty. Actually, "AAAAAAAAAA" appears exactly once, so no repeats found.

example_3.py — Short String

$ Input: s = "AAAAAAAAAA"

› Output: []

💡 Note: The string has exactly 10 characters, so there's only one possible 10-letter sequence "AAAAAAAAAA" starting at position 0. Since it appears only once, no repeated sequences are found.

Visualization

Tap to expand

Understanding the Visualization

Initialize Scanner

Set up your 10-character window at the beginning of the DNA sequence

Slide and Record

Move the window one position at a time, recording each 10-letter sequence in your notebook

Detect Duplicates

When you see a sequence for the second time, immediately flag it as repeated

Continue Scanning

Keep sliding until you've covered the entire DNA sequence

Key Takeaway

🎯 Key Insight: Hash tables enable constant-time lookups, allowing us to detect repeated DNA sequences in a single pass through the data, making this approach optimal for genomic analysis.

Time & Space Complexity

Time Complexity

⏱️

O(n)

We make one pass through the string, and each hash table operation takes O(1) time on average

✓ Linear Growth

Space Complexity

O(n)

In worst case, we might store all unique 10-character substrings in the hash table

⚡ Linearithmic Space

Constraints

1 ≤ s.length ≤ 10⁵
s[i] is either 'A', 'C', 'G', or 'T'
Only valid DNA nucleotides are present in the input

Asked in

a Amazon 45 G Google 32 ⊞ Microsoft 28 f Meta 22

The optimal solution uses a one-pass hash table approach with sliding window technique. As we slide a 10-character window through the DNA sequence, we track each subsequence in a hash map with its count. When a sequence count reaches 2, we immediately add it to results. This achieves O(n) time complexity and O(n) space complexity, making it highly efficient for large DNA sequences.

Common Approaches

Approach	Time	Space	Notes
✓ One-Pass Hash Table (Optimal)	O(n)	O(n)	Use sliding window with hash table to track sequences and detect repeats in single pass
Brute Force (Extract and Compare)	O(n²)	O(n)	Extract all 10-letter substrings, then find duplicates by comparing each against all others

One-Pass Hash Table (Optimal) — Algorithm Steps

Initialize a hash table to count sequences and a set for results
Slide a 10-character window through the DNA sequence
For each window position, extract the 10-character substring
Increment count in hash table; if count becomes 2, add to results
Return the list of repeated sequences

Visualization

Tap to expand

Step-by-Step Walkthrough

Sliding Window

Move 10-character window through DNA sequence

Hash & Count

Track each sequence in hash table with count

Detect Repeats

When count reaches 2, add to results immediately

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#define MAX_LEN 100000
#define MAX_RESULTS 10000
#define HASH_SIZE 100003

typedef struct HashNode {
    char sequence[11];
    int count;
    struct HashNode* next;
} HashNode;

HashNode* hashTable[HASH_SIZE];
char* results[MAX_RESULTS];
int result_count = 0;

unsigned int hash(char* str) {
    unsigned int hash = 5381;
    for (int i = 0; i < 10; i++) {
        hash = ((hash << 5) + hash) + str[i];
    }
    return hash % HASH_SIZE;
}

int getCount(char* sequence) {
    unsigned int index = hash(sequence);
    HashNode* node = hashTable[index];
    
    while (node != NULL) {
        if (strncmp(node->sequence, sequence, 10) == 0) {
            return node->count;
        }
        node = node->next;
    }
    return 0;
}

void incrementCount(char* sequence) {
    unsigned int index = hash(sequence);
    HashNode* node = hashTable[index];
    
    while (node != NULL) {
        if (strncmp(node->sequence, sequence, 10) == 0) {
            node->count++;
            return;
        }
        node = node->next;
    }
    
    // Create new node
    HashNode* newNode = malloc(sizeof(HashNode));
    strncpy(newNode->sequence, sequence, 10);
    newNode->sequence[10] = '\0';
    newNode->count = 1;
    newNode->next = hashTable[index];
    hashTable[index] = newNode;
}

char** findRepeatedDnaSequences(char* s, int* returnSize) {
    int len = strlen(s);
    if (len < 10) {
        *returnSize = 0;
        return NULL;
    }
    
    // Initialize hash table
    for (int i = 0; i < HASH_SIZE; i++) {
        hashTable[i] = NULL;
    }
    result_count = 0;
    
    // Sliding window of size 10
    for (int i = 0; i <= len - 10; i++) {
        char sequence[11];
        strncpy(sequence, s + i, 10);
        sequence[10] = '\0';
        
        int oldCount = getCount(sequence);
        incrementCount(sequence);
        
        // If we see it for the second time, add to result
        if (oldCount == 1) {
            results[result_count] = malloc(11);
            strcpy(results[result_count], sequence);
            result_count++;
        }
    }
    
    *returnSize = result_count;
    return results;
}

int main() {
    char s[MAX_LEN];
    fgets(s, MAX_LEN, stdin);
    
    // Remove newline and quotes
    s[strcspn(s, "\n")] = 0;
    if (s[0] == '"') {
        memmove(s, s+1, strlen(s));
        s[strlen(s)-1] = '\0';
    }
    
    int returnSize;
    char** result = findRepeatedDnaSequences(s, &returnSize);
    
    printf("[");
    for (int i = 0; i < returnSize; i++) {
        printf("\"%s\"", result[i]);
        if (i < returnSize-1) printf(",");
        free(result[i]);
    }
    printf("]\n");
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

We make one pass through the string, and each hash table operation takes O(1) time on average

✓ Linear Growth

Space Complexity

O(n)

In worst case, we might store all unique 10-character substrings in the hash table

⚡ Linearithmic Space

Constraints

1 ≤ s.length ≤ 10⁵
s[i] is either 'A', 'C', 'G', or 'T'
Only valid DNA nucleotides are present in the input

87.6K Views

Medium-High Frequency

~15 min Avg. Time

3.2K Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Input & Output

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

One-Pass Hash Table (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler