DNA Pattern Recognition - Practice Coding Problems

DNA Pattern Recognition - Problem

Database Medium

🧬 Dive into the fascinating world of bioinformatics! As a computational biologist, you're analyzing DNA sequences to identify important genetic patterns that could reveal insights about different species.

You have a database table Samples containing DNA sequences from various species. Your task is to scan each sequence and detect four crucial biological patterns:

Start Codon: Sequences beginning with ATG (signals protein synthesis start)
Stop Codons: Sequences ending with TAA, TAG, or TGA (signals protein synthesis end)
ATAT Motif: Sequences containing the repeating pattern ATAT
Triple G Pattern: Sequences with at least 3 consecutive G's (like GGG or GGGG)

For each DNA sample, return boolean flags indicating which patterns are present, ordered by sample_id.

Input: Table with sample_id, dna_sequence (A,T,G,C characters), and species
Output: All columns plus four pattern detection flags: has_start, has_stop, has_atat, has_ggg

Input & Output

example_1.py — Basic Pattern Detection

$ Input: Samples: [(1, 'ATGCTAGCTAGCTAA', 'Human'), (2, 'GGGTCAATCATC', 'Human')]

› Output: [(1, 'ATGCTAGCTAGCTAA', 'Human', 1, 1, 0, 0), (2, 'GGGTCAATCATC', 'Human', 0, 0, 0, 1)]

💡 Note: Sample 1 has start codon ATG and stop codon TAA. Sample 2 has triple G pattern GGG but no other patterns.

example_2.py — ATAT Motif Detection

$ Input: Samples: [(3, 'ATATATCGTAGCTA', 'Human'), (6, 'ATATCGCGCTAG', 'Zebrafish')]

› Output: [(3, 'ATATATCGTAGCTA', 'Human', 0, 0, 1, 0), (6, 'ATATCGCGCTAG', 'Zebrafish', 0, 1, 1, 0)]

💡 Note: Both sequences contain ATAT motif. Sample 6 also ends with TAG stop codon.

example_3.py — Complex Pattern Combination

$ Input: Samples: [(4, 'ATGGGGTCATCATAA', 'Mouse')]

› Output: [(4, 'ATGGGGTCATCATAA', 'Mouse', 1, 1, 0, 1)]

💡 Note: This sequence demonstrates multiple patterns: starts with ATG, contains GGGG (4 consecutive Gs), and ends with TAA.

Constraints

1 ≤ number of samples ≤ 10³
1 ≤ length of dna_sequence ≤ 10⁴
DNA sequences contain only characters A, T, G, C
sample_id values are unique integers
species names are non-empty strings

Visualization

Tap to expand

Understanding the Visualization

Load DNA Sequence

Read the genetic code string from the database

Apply Pattern Matchers

Use SQL functions to check for start/stop codons and motifs

Generate Boolean Flags

Convert pattern matches into 1/0 flags for each pattern type

Return Sorted Results

Order by sample_id and return comprehensive pattern analysis

Key Takeaway

🎯 Key Insight: SQL's built-in pattern matching functions (LIKE, REGEXP, LEFT, RIGHT) enable efficient detection of multiple biological patterns in a single database query, making this approach both elegant and performant for bioinformatics applications.

Asked in

G Google 35 a Amazon 28 ⊞ Microsoft 22 f Meta 18

The optimal solution uses SQL pattern matching functions like LEFT(), RIGHT(), POSITION(), and REGEXP to detect all four DNA patterns in a single query execution. Key techniques include: using CASE WHEN statements for boolean flags, string functions for start/end codon detection, and regular expressions for complex pattern matching like consecutive G's.

Common Approaches

Approach	Time	Space	Notes
✓ Multiple Pattern Checks	O(n * m)	O(1)	Use separate functions to check each pattern individually
Optimized SQL Pattern Matching	O(n * m)	O(1)	Use advanced SQL functions and regular expressions for efficient pattern detection

Multiple Pattern Checks — Algorithm Steps

Check if sequence starts with 'ATG' using LEFT() function
Check if sequence ends with any stop codon using RIGHT() and OR conditions
Search for 'ATAT' substring anywhere in the sequence
Look for 3+ consecutive G's using pattern matching
Combine all checks into boolean flags

Visualization

Tap to expand

Step-by-Step Walkthrough

Check Start Codon

Scan first 3 characters for ATG

Check Stop Codons

Scan last 3 characters for TAA/TAG/TGA

Check ATAT Motif

Search entire sequence for ATAT substring

Check Triple G

Search entire sequence for GGG+ pattern

Code -

solution.c — C

// SQL Solution
const char* query = 
"SELECT \n"
"    sample_id,\n"
"    dna_sequence,\n"
"    species,\n"
"    CASE WHEN dna_sequence LIKE 'ATG%' THEN 1 ELSE 0 END as has_start,\n"
"    CASE WHEN dna_sequence LIKE '%TAA' OR dna_sequence LIKE '%TAG' OR dna_sequence LIKE '%TGA' THEN 1 ELSE 0 END as has_stop,\n"
"    CASE WHEN dna_sequence LIKE '%ATAT%' THEN 1 ELSE 0 END as has_atat,\n"
"    CASE WHEN dna_sequence LIKE '%GGG%' THEN 1 ELSE 0 END as has_ggg\n"
"FROM Samples\n"
"ORDER BY sample_id;";

// For testing with C
int checkPattern(const char* seq, const char* pattern, int mode) {
    // mode: 0=starts, 1=ends, 2=contains
    int seqLen = strlen(seq), patLen = strlen(pattern);
    if (mode == 0) return strncmp(seq, pattern, patLen) == 0 ? 1 : 0;
    if (mode == 1) return seqLen >= patLen && strcmp(seq + seqLen - patLen, pattern) == 0 ? 1 : 0;
    return strstr(seq, pattern) != NULL ? 1 : 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n * m)

Where n is number of sequences and m is average sequence length, scanning each sequence multiple times

✓ Linear Growth

Space Complexity

O(1)

Only storing boolean results, no additional space for sequence processing

✓ Linear Space

32.0K Views

Medium Frequency

~15 min Avg. Time

1.5K 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

Constraints

Visualization

Related Problems

Common Approaches

Multiple Pattern Checks — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler