Find Products with Three Consecutive Digits

Find Products with Three Consecutive Digits - Problem

Database Easy

Given a products database, you need to identify products whose names contain exactly three consecutive digits in a sequence.

Your task is to write a SQL query that finds all products meeting this criteria. The challenge is to detect patterns like 123, 789, or 003 within product names, but reject patterns with more or fewer consecutive digits.

Key Points:

Must be exactly 3 consecutive digits (not 2, not 4+)
Digits must be in a row with no interruption
Product names may contain multiple such sequences
Return results ordered by product_id ascending

Example: ABC123XYZ ✅ (contains 123), Product56789 ❌ (contains 5 digits), A12B34C ❌ (digits separated by letters)

Input & Output

example_1.sql — Basic Pattern Match

$ Input: Products table: +-------------+--------------------+ | product_id | name | +-------------+--------------------+ | 1 | ABC123XYZ | | 4 | NoDigitsHere | +-------------+--------------------+

› Output: +-------------+--------------------+ | product_id | name | +-------------+--------------------+ | 1 | ABC123XYZ | +-------------+--------------------+

💡 Note: Product 1 contains exactly 3 consecutive digits '123' surrounded by letters. Product 4 has no digits at all.

example_2.sql — Edge Cases

$ Input: Products table: +-------------+--------------------+ | product_id | name | +-------------+--------------------+ | 3 | Product56789 | | 6 | Item003Description | | 7 | Product12X34 | +-------------+--------------------+

› Output: +-------------+--------------------+ | product_id | name | +-------------+--------------------+ | 6 | Item003Description | +-------------+--------------------+

💡 Note: Product 3 has 5 consecutive digits (too many). Product 6 has exactly 3 digits '003'. Product 7 has digits separated by 'X'.

example_3.sql — Boundary Cases

$ Input: Products table: +-------------+--------------------+ | product_id | name | +-------------+--------------------+ | 8 | 789Product | | 9 | Product123 | | 10 | 123 | +-------------+--------------------+

› Output: +-------------+--------------------+ | product_id | name | +-------------+--------------------+ | 8 | 789Product | | 9 | Product123 | | 10 | 123 | +-------------+--------------------+

💡 Note: All three products have exactly 3 consecutive digits at different positions: start, end, and entire string.

Constraints

1 ≤ product_id ≤ 10⁴
1 ≤ name.length ≤ 100
Product names contain only alphanumeric characters
Each product_id is unique

Visualization

Tap to expand

Understanding the Visualization

Scan Product Name

Examine each character in the product name sequentially

Detect Digit Patterns

Identify sequences of consecutive digits

Validate Length

Ensure exactly 3 digits, not more or fewer

Check Boundaries

Verify digits aren't part of longer sequence

Key Takeaway

🎯 Key Insight: Regular expressions with boundary assertions provide the most efficient way to match exact patterns while avoiding false positives from longer sequences.

Asked in

a Amazon 45 ⊞ Microsoft 38 G Google 32 f Meta 25

The optimal solution uses regular expression pattern matching with the pattern (^|[^0-9])[0-9]{3}([^0-9]|$) to find products containing exactly 3 consecutive digits. This pattern ensures the digits are not part of a longer sequence by checking boundaries.

Common Approaches

Approach	Time	Space	Notes
✓ Regular Expression Pattern Matching (Optimal)	O(n * m)	O(1)	Use regex pattern matching to directly identify exactly 3 consecutive digits
Manual String Scanning	O(n * m)	O(1)	Manually iterate through each character position and check for 3-digit patterns

Regular Expression Pattern Matching (Optimal) — Algorithm Steps

Use regex pattern with negative lookbehind to ensure no digit precedes
Match exactly 3 consecutive digits [0-9]{3}
Use negative lookahead to ensure no digit follows
Apply the pattern to filter products in a single pass

Visualization

Tap to expand

Step-by-Step Walkthrough

Pattern Setup

Regex engine compiles pattern: (^|[^0-9])[0-9]{3}([^0-9]|$)

Boundary Check

Ensures 3 digits are not part of longer sequence

Match Found

Pattern matches and product is included in results

Code -

solution.c — C

// Optimal SQL solution
char* sqlQuery = 
"SELECT product_id, name "
"FROM Products "
"WHERE name REGEXP '(^|[^0-9])[0-9]{3}([^0-9]|$)' "
"ORDER BY product_id;";

// C implementation (simplified, would need regex library)
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <ctype.h>

typedef struct {
    int product_id;
    char name[100];
} Product;

int hasThreeConsecutiveDigits(const char* name) {
    int len = strlen(name);
    
    for (int i = 0; i <= len - 3; i++) {
        // Check if we have 3 digits
        if (isdigit(name[i]) && isdigit(name[i+1]) && isdigit(name[i+2])) {
            // Check boundaries
            int prevOk = (i == 0) || !isdigit(name[i-1]);
            int nextOk = (i + 3 >= len) || !isdigit(name[i+3]);
            
            if (prevOk && nextOk) {
                return 1;
            }
        }
    }
    return 0;
}

int compareProducts(const void* a, const void* b) {
    Product* prodA = (Product*)a;
    Product* prodB = (Product*)b;
    return prodA->product_id - prodB->product_id;
}

Time & Space Complexity

Time Complexity

⏱️

O(n * m)

Linear scan of n products × m string length, but optimized by database regex engine

✓ Linear Growth

Space Complexity

O(1)

No additional space beyond result set, regex engine handles pattern matching internally

✓ Linear Space

28.4K Views

Medium Frequency

~15 min Avg. Time

850 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

Regular Expression Pattern Matching (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler