⚡️ Speed up function regex_match by 123%

[codeflash-ai]

📄 123% (1.23x) speedup for regex_match in src/dsa/various.py

⏱️ Runtime : 3.20 milliseconds → 1.43 milliseconds (best of 67 runs)

📝 Explanation and details

The optimization achieves a 122% speedup by making two key improvements:

1. Pre-compiling the regex pattern: Instead of calling re.match(pattern, s) in each loop iteration, the optimized version compiles the pattern once with re.compile(pattern) and reuses the compiled object. This eliminates the overhead of parsing and compiling the same regex pattern thousands of times.

2. Using list comprehension: Replacing the explicit loop and append operations with a list comprehension [s for s in strings if compiled_pattern.match(s)] reduces function call overhead and leverages Python's optimized C implementation for list construction.

The line profiler shows the dramatic impact: the original code spent 84.6% of its time in the re.match(pattern, s) call, which was executed 10,134 times. The optimized version eliminates this repeated compilation overhead - the re.compile() call now represents only 77.5% of the much smaller total runtime.

Performance characteristics by test case:

• Large datasets see the biggest gains: 132-180% speedup on 1000-item lists, where regex compilation overhead compounds
• Small datasets show modest but consistent improvements: 15-40% speedup on basic cases with 3-5 strings
• Edge case with empty input list shows slight regression: 69% slower due to the upfront compilation cost not being amortized

This optimization is most effective when processing multiple strings with the same pattern, which is the typical use case for batch regex matching operations.

✅ Correctness verification report:

Test	Status
⚙️ Existing Unit Tests	🔘 None Found
🌀 Generated Regression Tests	✅ 31 Passed
⏪ Replay Tests	🔘 None Found
🔎 Concolic Coverage Tests	✅ 1 Passed
🔮 Hypothesis Tests	✅ 12 Passed
📊 Tests Coverage	100.0%

🌀 Generated Regression Tests and Runtime

from __future__ import annotations

import re

# imports
import pytest  # used for our unit tests
from src.dsa.various import regex_match

# unit tests

# --- Basic Test Cases ---

def test_basic_exact_match():
    # Test basic literal match
    strings = ["apple", "banana", "apricot", "applepie"]
    pattern = r"apple"
    # Only "apple" and "applepie" start with "apple"
    codeflash_output = regex_match(strings, pattern) # 4.21μs -> 3.25μs (29.5% faster)

def test_basic_digit_match():
    # Test digit pattern
    strings = ["123", "abc", "1a2b", "456"]
    pattern = r"\d+"
    # Only "123" and "456" start with digits
    codeflash_output = regex_match(strings, pattern) # 3.62μs -> 2.79μs (29.8% faster)

def test_basic_start_of_string():
    # Test ^ anchor
    strings = ["test", "contest", "testing", "tester"]
    pattern = r"^test"
    # Only "test", "testing", "tester" start with "test"
    codeflash_output = regex_match(strings, pattern) # 2.88μs -> 2.29μs (25.5% faster)

def test_basic_end_of_string():
    # Test $ anchor
    strings = ["hello", "yellow", "mellow", "low"]
    pattern = r"low$"
    # Only "yellow", "mellow", "low" end with "low"
    codeflash_output = regex_match(strings, pattern) # 2.54μs -> 2.08μs (22.0% faster)

def test_basic_dot_wildcard():
    # Test . wildcard
    strings = ["cat", "cot", "cut", "cit", "cmt"]
    pattern = r"c.t"
    # All strings match: c + any char + t
    codeflash_output = regex_match(strings, pattern) # 3.12μs -> 2.25μs (38.9% faster)

def test_basic_character_class():
    # Test character class
    strings = ["bat", "cat", "rat", "mat"]
    pattern = r"[bcr]at"
    # Only "bat", "cat", "rat" match
    codeflash_output = regex_match(strings, pattern) # 2.88μs -> 2.04μs (40.8% faster)

# --- Edge Test Cases ---

def test_edge_empty_strings_list():
    # Test with empty input list
    strings = []
    pattern = r".*"
    codeflash_output = regex_match(strings, pattern) # 333ns -> 1.08μs (69.3% slower)

def test_edge_empty_pattern():
    # Empty pattern only matches empty string at start
    strings = ["", "a", " "]
    pattern = r""
    # All strings match at position 0
    codeflash_output = regex_match(strings, pattern) # 2.54μs -> 2.17μs (17.3% faster)

def test_edge_empty_string_in_list():
    # Test with empty string in list
    strings = ["", "abc", " "]
    pattern = r"^$"
    # Only empty string matches pattern for start/end
    codeflash_output = regex_match(strings, pattern) # 2.42μs -> 1.96μs (23.4% faster)

def test_edge_special_characters():
    # Test with special regex characters
    strings = ["a.b", "aab", "abb", "a-b"]
    pattern = r"a.b"
    # Only "a.b" and "abb" match: a + any char + b
    codeflash_output = regex_match(strings, pattern) # 2.75μs -> 2.38μs (15.8% faster)

def test_edge_unicode_characters():
    # Test with unicode characters
    strings = ["café", "cafe", "cafè", "cafÉ"]
    pattern = r"caf."
    # All except "cafe" match (since "caf." requires 4 letters and a fifth char)
    codeflash_output = regex_match(strings, pattern) # 2.54μs -> 2.17μs (17.4% faster)

def test_edge_no_matches():
    # Test with no matches
    strings = ["dog", "cat", "mouse"]
    pattern = r"elephant"
    codeflash_output = regex_match(strings, pattern) # 2.12μs -> 1.75μs (21.4% faster)

def test_edge_pattern_longer_than_string():
    # Pattern longer than any string
    strings = ["hi", "hello", "hey"]
    pattern = r"hello world"
    codeflash_output = regex_match(strings, pattern) # 2.00μs -> 1.58μs (26.3% faster)

def test_edge_anchors_and_wildcards():
    # ^ and $ with .*
    strings = ["", "a", "abc"]
    pattern = r"^.*$"
    # All strings match
    codeflash_output = regex_match(strings, pattern) # 2.58μs -> 2.17μs (19.3% faster)

def test_edge_case_sensitive():
    # Regex is case-sensitive by default
    strings = ["Test", "test", "TEST"]
    pattern = r"test"
    codeflash_output = regex_match(strings, pattern) # 2.29μs -> 1.83μs (25.0% faster)

def test_edge_escape_sequences():
    # Test with escaped characters
    strings = ["a\\b", "a\b", "ab"]
    pattern = r"a\\b"
    # Only "a\\b" matches
    codeflash_output = regex_match(strings, pattern) # 2.50μs -> 2.00μs (25.0% faster)

def test_edge_multiple_matches():
    # Multiple matches in one string, but only start is checked
    strings = ["abcabc", "abc", "cab"]
    pattern = r"abc"
    # Only those starting with "abc"
    codeflash_output = regex_match(strings, pattern) # 2.33μs -> 1.88μs (24.4% faster)

def test_edge_non_ascii():
    # Non-ASCII characters
    strings = ["αβγ", "abc", "βγα"]
    pattern = r"α.*"
    codeflash_output = regex_match(strings, pattern) # 2.92μs -> 2.33μs (25.0% faster)

def test_edge_regex_with_optional():
    # Optional character
    strings = ["color", "colour", "colr", "col"]
    pattern = r"colou?r"
    # "color", "colour" match
    codeflash_output = regex_match(strings, pattern) # 3.00μs -> 2.42μs (24.1% faster)

def test_edge_regex_with_repetition():
    # Repetition quantifiers
    strings = ["aaa", "aa", "a", ""]
    pattern = r"a{2,}"
    # "aaa", "aa" match
    codeflash_output = regex_match(strings, pattern) # 3.08μs -> 2.25μs (37.1% faster)

def test_edge_regex_with_alternation():
    # Alternation
    strings = ["dog", "cat", "bat", "rat"]
    pattern = r"(dog|cat)"
    # "dog", "cat" match
    codeflash_output = regex_match(strings, pattern) # 2.88μs -> 2.42μs (18.9% faster)

# --- Large Scale Test Cases ---

def test_large_all_match():
    # All strings match a simple pattern
    strings = ["test" + str(i) for i in range(1000)]
    pattern = r"test\d+"
    # All strings start with "test" followed by digits
    codeflash_output = regex_match(strings, pattern) # 314μs -> 135μs (132% faster)

def test_large_none_match():
    # None of the strings match
    strings = ["foo" + str(i) for i in range(1000)]
    pattern = r"bar\d+"
    # None start with "bar"
    codeflash_output = regex_match(strings, pattern) # 263μs -> 94.4μs (180% faster)

def test_large_half_match():
    # Half of the strings match
    strings = ["match" + str(i) if i % 2 == 0 else "nomatch" + str(i) for i in range(1000)]
    pattern = r"match\d+"
    expected = ["match" + str(i) for i in range(0, 1000, 2)]
    codeflash_output = regex_match(strings, pattern) # 300μs -> 120μs (149% faster)

def test_large_varied_patterns():
    # Varied patterns, test performance and correctness
    strings = ["apple", "banana", "apricot", "grape", "pear"] * 200
    pattern = r"^a.*"
    # Only "apple", "apricot" match, repeated 200 times
    expected = (["apple", "apricot"] * 200)
    codeflash_output = regex_match(strings, pattern) # 292μs -> 119μs (145% faster)

def test_large_long_strings():
    # Test with long strings
    long_string = "a" * 500 + "b"
    strings = [long_string for _ in range(1000)]
    pattern = r"a{500}b"
    # All strings match
    codeflash_output = regex_match(strings, pattern) # 566μs -> 391μs (44.8% faster)

def test_large_mixed_characters():
    # Test with strings of varying length and content
    strings = ["x" * i for i in range(1, 1001)]
    pattern = r"x{1000}"
    # Only last string matches
    codeflash_output = regex_match(strings, pattern) # 263μs -> 95.3μs (177% faster)

def test_large_unicode():
    # Large set with unicode
    strings = ["α" * i for i in range(1, 1001)]
    pattern = r"α{1000}"
    codeflash_output = regex_match(strings, pattern) # 264μs -> 94.7μs (180% faster)

def test_large_empty_strings():
    # Large list of empty strings
    strings = [""] * 1000
    pattern = r"^$"
    # All match
    codeflash_output = regex_match(strings, pattern) # 306μs -> 125μs (143% faster)

def test_large_varied_no_match():
    # Large list, none match due to pattern
    strings = ["foo" + str(i) for i in range(1000)]
    pattern = r"^bar"
    codeflash_output = regex_match(strings, pattern) # 268μs -> 97.1μs (176% faster)

def test_large_special_characters():
    # Large list with special characters
    strings = ["a.b" if i % 2 == 0 else "ab" for i in range(1000)]
    pattern = r"a\.b"
    expected = ["a.b" for i in range(0, 1000, 2)]
    codeflash_output = regex_match(strings, pattern) # 299μs -> 113μs (163% faster)
# codeflash_output is used to check that the output of the original code is the same as that of the optimized code.
#------------------------------------------------
from src.dsa.various import regex_match

def test_regex_match():
    regex_match(['', '\x00'], '\x00')

🔎 Concolic Coverage Tests and Runtime

Test File::Test Function	Original ⏱️	Optimized ⏱️	Speedup
codeflash_concolic_fb1xiyqb/tmp4_8bu8uz/test_concolic_coverage.py::test_regex_match	2.08μs	1.79μs	16.2%✅

To edit these changes git checkout codeflash/optimize-regex_match-mha7uwlu and push.