⚡️ Speed up function string_concat by 36%

[codeflash-ai]

📄 36% (0.36x) speedup for string_concat in src/dsa/various.py

⏱️ Runtime : 317 microseconds → 232 microseconds (best of 997 runs)

📝 Explanation and details

The optimization replaces inefficient string concatenation with a list-based approach that eliminates quadratic time complexity.

Key optimization applied:

• Original approach: Uses s += str(i) in a loop, which creates a new string object on each iteration since strings are immutable in Python
• Optimized approach: Collects all string parts in a list using list comprehension, then joins them in a single operation

Why this leads to speedup:
The original code exhibits O(n²) time complexity because each += operation must copy the entire existing string plus the new part. For n iterations, this results in copying 1 + 2 + 3 + ... + n characters, totaling O(n²) operations.

The optimized version runs in O(n) time:

1. List comprehension [str(i) for i in range(n)] performs n string conversions and list appends
2. ''.join(parts) concatenates all parts in a single pass through the list

Performance characteristics by test case size:

• Small inputs (n < 100): The optimization shows modest improvements or even slight slowdowns due to list creation overhead
• Medium inputs (n ≈ 100-500): Performance gains become noticeable (1-4% faster)
• Large inputs (n ≈ 1000): Dramatic speedups of 42-45% faster, demonstrating the quadratic vs linear complexity difference

The line profiler confirms this: the original code spends 52.3% of time in the string concatenation loop, while the optimized version completes the entire operation in just two efficient steps. The optimization is particularly effective for larger inputs where the quadratic behavior of repeated string copying becomes the dominant performance bottleneck.

✅ Correctness verification report:

Test	Status
⚙️ Existing Unit Tests	🔘 None Found
🌀 Generated Regression Tests	✅ 55 Passed
⏪ Replay Tests	🔘 None Found
🔎 Concolic Coverage Tests	🔘 None Found
📊 Tests Coverage	100.0%

🌀 Generated Regression Tests and Runtime

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

# unit tests

# ------------------------
# 1. Basic Test Cases
# ------------------------

def test_concat_zero():
    # Test with n=0 should return an empty string
    codeflash_output = string_concat(0) # 167ns -> 250ns (33.2% slower)

def test_concat_one():
    # Test with n=1 should return "0"
    codeflash_output = string_concat(1) # 250ns -> 292ns (14.4% slower)

def test_concat_small_positive():
    # Test with n=3 should return "012"
    codeflash_output = string_concat(3) # 333ns -> 416ns (20.0% slower)
    # Test with n=5 should return "01234"
    codeflash_output = string_concat(5) # 250ns -> 291ns (14.1% slower)

def test_concat_typical():
    # Test with n=10 should return "0123456789"
    codeflash_output = string_concat(10) # 542ns -> 625ns (13.3% slower)

# ------------------------
# 2. Edge Test Cases
# ------------------------

def test_concat_negative():
    # Test with negative n should return an empty string (since range(-1) is empty)
    codeflash_output = string_concat(-1) # 208ns -> 250ns (16.8% slower)
    codeflash_output = string_concat(-100) # 125ns -> 125ns (0.000% faster)

def test_concat_large_single_digit():
    # Test with n=10, should return all digits 0-9
    codeflash_output = string_concat(10) # 542ns -> 584ns (7.19% slower)

def test_concat_non_integer_input():
    # Test with non-integer input should raise TypeError
    with pytest.raises(TypeError):
        string_concat("5") # 333ns -> 292ns (14.0% faster)
    with pytest.raises(TypeError):
        string_concat(3.14) # 250ns -> 209ns (19.6% faster)
    with pytest.raises(TypeError):
        string_concat(None) # 166ns -> 208ns (20.2% slower)
    with pytest.raises(TypeError):
        string_concat([5]) # 208ns -> 208ns (0.000% faster)

def test_concat_boundary_near_zero():
    # Test with n=1 and n=-1 (already tested, but for clarity)
    codeflash_output = string_concat(1) # 250ns -> 291ns (14.1% slower)
    codeflash_output = string_concat(-1) # 125ns -> 125ns (0.000% faster)

def test_concat_large_digit_transition():
    # Test with n=11 to ensure two-digit numbers are handled correctly
    codeflash_output = string_concat(11) # 625ns -> 667ns (6.30% slower)

def test_concat_mutation_detection():
    # Ensure that all digits are present and in correct order for n=20
    codeflash_output = string_concat(20); result = codeflash_output # 875ns -> 917ns (4.58% slower)
    expected = ''.join(str(i) for i in range(20))
    # Ensure no digit is missing or duplicated
    for i in range(20):
        pass

# ------------------------
# 3. Large Scale Test Cases
# ------------------------

def test_concat_large_n_100():
    # Test with n=100, should concatenate "012345...9899"
    codeflash_output = string_concat(100); result = codeflash_output # 3.42μs -> 3.54μs (3.56% slower)
    expected = ''.join(str(i) for i in range(100))
    # Check length: sum of lengths of all numbers from 0 to 99
    expected_length = sum(len(str(i)) for i in range(100))

def test_concat_large_n_999():
    # Test with n=999, near upper limit for this test suite
    codeflash_output = string_concat(999); result = codeflash_output # 47.5μs -> 33.3μs (42.8% faster)
    expected = ''.join(str(i) for i in range(999))
    # Check total length
    expected_length = sum(len(str(i)) for i in range(999))

def test_concat_performance_reasonable():
    # This test ensures that the function can handle n=1000 in reasonable time and memory
    n = 1000
    codeflash_output = string_concat(n); result = codeflash_output # 47.8μs -> 33.0μs (44.8% faster)
    expected = ''.join(str(i) for i in range(n))

# ------------------------
# 4. Additional Robustness Tests
# ------------------------

@pytest.mark.parametrize("n", [0, 1, 2, 10, 50, 100, 500])
def test_concat_parametrized(n):
    # Parametrized test to check a variety of n values
    codeflash_output = string_concat(n) # 29.4μs -> 23.5μs (25.2% faster)

def test_concat_extreme_large_number():
    # Test with n=999 (upper bound for this suite)
    n = 999
    codeflash_output = string_concat(n); result = codeflash_output # 47.7μs -> 32.9μs (44.8% faster)
    # Check that all numbers are present and in order
    for i in range(n):
        idx = result.find(str(i))
        # For two-digit and three-digit numbers, check that they appear only once
        if i >= 10:
            pass

def test_concat_no_mutation():
    # Test to ensure that a function returning reversed order fails
    wrong = ''.join(str(i) for i in reversed(range(10)))
    codeflash_output = string_concat(10) # 541ns -> 583ns (7.20% slower)

def test_concat_no_truncation():
    # Test to ensure that a function omitting the last number fails
    n = 20
    wrong = ''.join(str(i) for i in range(n-1))
    codeflash_output = string_concat(n) # 833ns -> 834ns (0.120% slower)
# codeflash_output is used to check that the output of the original code is the same as that of the optimized code.

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

# unit tests

# 1. Basic Test Cases

def test_concat_zero():
    # Test with n = 0 (should return empty string)
    codeflash_output = string_concat(0) # 167ns -> 250ns (33.2% slower)

def test_concat_one():
    # Test with n = 1 (should return "0")
    codeflash_output = string_concat(1) # 250ns -> 292ns (14.4% slower)

def test_concat_two():
    # Test with n = 2 (should return "01")
    codeflash_output = string_concat(2) # 291ns -> 375ns (22.4% slower)

def test_concat_small_number():
    # Test with n = 5 (should return "01234")
    codeflash_output = string_concat(5) # 334ns -> 500ns (33.2% slower)

def test_concat_typical_number():
    # Test with n = 10 (should return "0123456789")
    codeflash_output = string_concat(10) # 541ns -> 625ns (13.4% slower)

# 2. Edge Test Cases

def test_concat_negative():
    # Test with negative n (should return empty string, as range(-1) is empty)
    codeflash_output = string_concat(-1) # 208ns -> 250ns (16.8% slower)
    codeflash_output = string_concat(-100) # 125ns -> 125ns (0.000% faster)

def test_concat_large_single_digit_transition():
    # Test with n = 10 (transition from single to double digit)
    codeflash_output = string_concat(10) # 542ns -> 625ns (13.3% slower)

def test_concat_double_digit_transition():
    # Test with n = 100 (transition from double to triple digit)
    expected = ''.join(str(i) for i in range(100))
    codeflash_output = string_concat(100) # 3.38μs -> 3.33μs (1.26% faster)

def test_concat_non_integer_input():
    # Test with non-integer input: should raise TypeError
    with pytest.raises(TypeError):
        string_concat("10") # 333ns -> 292ns (14.0% faster)
    with pytest.raises(TypeError):
        string_concat(5.5) # 250ns -> 209ns (19.6% faster)
    with pytest.raises(TypeError):
        string_concat(None) # 208ns -> 208ns (0.000% faster)
    with pytest.raises(TypeError):
        string_concat([10]) # 208ns -> 208ns (0.000% faster)

def test_concat_maximum_single_digit():
    # Test with n = 9 (should return "012345678")
    codeflash_output = string_concat(9) # 541ns -> 625ns (13.4% slower)

def test_concat_empty_string_output():
    # Test with n = 0 (should return empty string)
    codeflash_output = string_concat(0) # 208ns -> 250ns (16.8% slower)

def test_concat_large_negative():
    # Test with a very large negative number
    codeflash_output = string_concat(-999) # 208ns -> 250ns (16.8% slower)


def test_concat_large_n_100():
    # Test with n = 100 (should handle without performance issues)
    expected = ''.join(str(i) for i in range(100))
    codeflash_output = string_concat(100) # 3.33μs -> 3.29μs (1.28% faster)

def test_concat_large_n_999():
    # Test with n = 999 (close to upper allowed limit for this suite)
    expected = ''.join(str(i) for i in range(999))
    codeflash_output = string_concat(999) # 47.8μs -> 32.9μs (45.2% faster)

def test_concat_performance_large_n():
    # Test with n = 1000 (upper limit for this suite; focus on correctness)
    expected = ''.join(str(i) for i in range(1000))
    codeflash_output = string_concat(1000) # 47.6μs -> 32.8μs (45.4% faster)

def test_concat_large_output_length():
    # Test that the output string length matches the sum of digits of all numbers from 0 to n-1
    n = 500
    codeflash_output = string_concat(n); result = codeflash_output # 22.7μs -> 16.5μs (38.0% faster)
    expected_length = sum(len(str(i)) for i in range(n))

def test_concat_no_extra_characters():
    # Ensure no extra whitespace or separators are present in the output
    n = 50
    codeflash_output = string_concat(n); result = codeflash_output # 1.83μs -> 1.83μs (0.000% faster)

# 4. Additional Edge Cases

def test_concat_n_is_maxsize():
    # Test with n = 0 (should return empty string, sys.maxsize would be too large for this suite)
    codeflash_output = string_concat(0) # 166ns -> 250ns (33.6% slower)

def test_concat_mutation_resistance():
    # Ensure that skipping any number or changing the order will fail
    n = 20
    codeflash_output = string_concat(n); correct = codeflash_output # 875ns -> 917ns (4.58% slower)
    # Remove one digit from the result and check that it fails
    mutated = correct[:5] + correct[6:]
    codeflash_output = string_concat(n) # 708ns -> 750ns (5.60% slower)
    # Reverse the result and check that it fails
    codeflash_output = string_concat(n) # 667ns -> 667ns (0.000% faster)
    # Shuffle the digits and check that it fails
    shuffled = ''.join(sorted(correct))
    codeflash_output = string_concat(n) # 708ns -> 667ns (6.15% faster)
# codeflash_output is used to check that the output of the original code is the same as that of the optimized code.

To edit these changes git checkout codeflash/optimize-string_concat-mdpc1jpr and push.