⚡️ Speed up function find_common_tags by 23%

[codeflash-ai]

📄 23% (0.23x) speedup for find_common_tags in src/algorithms/string.py

⏱️ Runtime : 7.67 milliseconds → 6.23 milliseconds (best of 87 runs)

📝 Explanation and details

Key optimizations:

• Pre-extract all tag lists upfront (avoids repeated .get("tags", []) lookups in the critical loop).
• Early exit if any tag list is empty (intersection must be empty if any is empty).
• Sort tag lists by size before intersection to reduce intermediate set size as quickly as possible (much faster for many articles, especially when tag set sizes vary).
• All comments and code behavior are preserved. The return values, exceptions, and input/output remain exactly as in the original code.

✅ Correctness verification report:

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

⚙️ Existing Unit Tests and Runtime

Test File::Test Function	Original ⏱️	Optimized ⏱️	Speedup
test_common_tags.py::test_common_tags_1	2.33μs	4.29μs	-45.6%⚠️

🌀 Generated Regression Tests and Runtime

# imports
# function to test
from __future__ import annotations

import pytest  # used for our unit tests
from codeflash.result.common_tags import find_common_tags

# unit tests


def test_single_article():
    # Single article should return its tags
    articles = [{"tags": ["python", "coding", "tutorial"]}]
    codeflash_output = find_common_tags(articles)  # 666ns -> 1.75μs (61.9% slower)
    # Outputs were verified to be equal to the original implementation


def test_multiple_articles_with_common_tags():
    # Multiple articles with common tags should return the common tags
    articles = [
        {"tags": ["python", "coding"]},
        {"tags": ["python", "data"]},
        {"tags": ["python", "machine learning"]},
    ]
    codeflash_output = find_common_tags(articles)  # 1.21μs -> 2.50μs (51.7% slower)
    # Outputs were verified to be equal to the original implementation


def test_empty_list_of_articles():
    # Empty list of articles should return an empty set
    articles = []
    codeflash_output = find_common_tags(articles)  # 291ns -> 291ns (0.000% faster)
    # Outputs were verified to be equal to the original implementation


def test_articles_with_no_common_tags():
    # Articles with no common tags should return an empty set
    articles = [{"tags": ["python"]}, {"tags": ["java"]}, {"tags": ["c++"]}]
    codeflash_output = find_common_tags(articles)  # 1.00μs -> 2.38μs (57.9% slower)
    # Outputs were verified to be equal to the original implementation


def test_articles_with_empty_tag_lists():
    # Articles with some empty tag lists should return an empty set
    articles = [{"tags": []}, {"tags": ["python"]}, {"tags": ["python", "java"]}]
    codeflash_output = find_common_tags(articles)  # 959ns -> 1.25μs (23.3% slower)
    # Outputs were verified to be equal to the original implementation


def test_all_articles_with_empty_tag_lists():
    # All articles with empty tag lists should return an empty set
    articles = [{"tags": []}, {"tags": []}, {"tags": []}]
    codeflash_output = find_common_tags(articles)  # 916ns -> 1.29μs (29.1% slower)
    # Outputs were verified to be equal to the original implementation


def test_tags_with_special_characters():
    # Tags with special characters should be handled correctly
    articles = [{"tags": ["python!", "coding"]}, {"tags": ["python!", "data"]}]
    codeflash_output = find_common_tags(articles)  # 1.12μs -> 2.33μs (51.8% slower)
    # Outputs were verified to be equal to the original implementation


def test_case_sensitivity():
    # Tags with different cases should not be considered the same
    articles = [{"tags": ["Python", "coding"]}, {"tags": ["python", "data"]}]
    codeflash_output = find_common_tags(articles)  # 1.00μs -> 2.38μs (57.9% slower)
    # Outputs were verified to be equal to the original implementation


def test_large_number_of_articles():
    # Large number of articles with a common tag should return that tag
    articles = [{"tags": ["common_tag", f"tag{i}"]} for i in range(1000)]
    codeflash_output = find_common_tags(articles)  # 116μs -> 169μs (31.1% slower)
    # Outputs were verified to be equal to the original implementation


def test_large_number_of_tags():
    # Large number of tags with some common tags should return the common tags
    articles = [
        {"tags": [f"tag{i}" for i in range(1000)]},
        {"tags": [f"tag{i}" for i in range(500, 1500)]},
    ]
    expected = {f"tag{i}" for i in range(500, 1000)}
    codeflash_output = find_common_tags(articles)  # 63.6μs -> 60.9μs (4.38% faster)
    # Outputs were verified to be equal to the original implementation


def test_mixed_length_of_tag_lists():
    # Articles with mixed length of tag lists should return the common tags
    articles = [
        {"tags": ["python", "coding"]},
        {"tags": ["python"]},
        {"tags": ["python", "coding", "tutorial"]},
    ]
    codeflash_output = find_common_tags(articles)  # 1.25μs -> 2.50μs (50.0% slower)
    # Outputs were verified to be equal to the original implementation


def test_tags_with_different_data_types():
    # Tags with different data types should only consider strings
    articles = [{"tags": ["python", 123]}, {"tags": ["python", "123"]}]
    codeflash_output = find_common_tags(articles)  # 1.00μs -> 2.29μs (56.4% slower)
    # Outputs were verified to be equal to the original implementation


def test_performance_with_large_data():
    # Performance with large data should return the common tag
    articles = [{"tags": ["common_tag", f"tag{i}"]} for i in range(10000)]
    codeflash_output = find_common_tags(articles)  # 1.15ms -> 1.63ms (29.2% slower)
    # Outputs were verified to be equal to the original implementation


def test_scalability_with_increasing_tags():
    # Scalability with increasing tags should return the common tag
    articles = [
        {"tags": ["common_tag"] + [f"tag{i}" for i in range(j)]} for j in range(1, 1001)
    ]
    codeflash_output = find_common_tags(articles)  # 317μs -> 365μs (13.1% slower)
    # Outputs were verified to be equal to the original implementation

# imports
# function to test
from __future__ import annotations

import pytest  # used for our unit tests
from codeflash.result.common_tags import find_common_tags

# unit tests


def test_empty_input_list():
    # Test with an empty list
    codeflash_output = find_common_tags([])  # 333ns -> 333ns (0.000% faster)
    # Outputs were verified to be equal to the original implementation


def test_single_article():
    # Test with a single article with tags
    codeflash_output = find_common_tags(
        [{"tags": ["python", "coding", "development"]}]
    )  # 875ns -> 1.96μs (55.3% slower)
    # Test with a single article with no tags
    codeflash_output = find_common_tags([{"tags": []}])  # 333ns -> 666ns (50.0% slower)
    # Outputs were verified to be equal to the original implementation


def test_multiple_articles_some_common_tags():
    # Test with multiple articles having some common tags
    articles = [
        {"tags": ["python", "coding", "development"]},
        {"tags": ["python", "development", "tutorial"]},
        {"tags": ["python", "development", "guide"]},
    ]
    codeflash_output = find_common_tags(articles)  # 1.46μs -> 2.92μs (50.0% slower)

    articles = [
        {"tags": ["tech", "news"]},
        {"tags": ["tech", "gadgets"]},
        {"tags": ["tech", "reviews"]},
    ]
    codeflash_output = find_common_tags(articles)  # 750ns -> 1.38μs (45.5% slower)
    # Outputs were verified to be equal to the original implementation


def test_multiple_articles_no_common_tags():
    # Test with multiple articles having no common tags
    articles = [
        {"tags": ["python", "coding"]},
        {"tags": ["development", "tutorial"]},
        {"tags": ["guide", "learning"]},
    ]
    codeflash_output = find_common_tags(articles)  # 1.04μs -> 2.33μs (55.4% slower)

    articles = [
        {"tags": ["apple", "banana"]},
        {"tags": ["orange", "grape"]},
        {"tags": ["melon", "kiwi"]},
    ]
    codeflash_output = find_common_tags(articles)  # 500ns -> 1.25μs (60.0% slower)
    # Outputs were verified to be equal to the original implementation


def test_articles_with_duplicate_tags():
    # Test with articles having duplicate tags
    articles = [
        {"tags": ["python", "python", "coding"]},
        {"tags": ["python", "development", "python"]},
        {"tags": ["python", "guide", "python"]},
    ]
    codeflash_output = find_common_tags(articles)  # 1.33μs -> 2.62μs (49.2% slower)

    articles = [
        {"tags": ["tech", "tech", "news"]},
        {"tags": ["tech", "tech", "gadgets"]},
        {"tags": ["tech", "tech", "reviews"]},
    ]
    codeflash_output = find_common_tags(articles)  # 791ns -> 1.33μs (40.7% slower)
    # Outputs were verified to be equal to the original implementation


def test_articles_with_mixed_case_tags():
    # Test with articles having mixed case tags
    articles = [
        {"tags": ["Python", "Coding"]},
        {"tags": ["python", "Development"]},
        {"tags": ["PYTHON", "Guide"]},
    ]
    codeflash_output = find_common_tags(articles)  # 1.00μs -> 2.33μs (57.2% slower)

    articles = [
        {"tags": ["Tech", "News"]},
        {"tags": ["tech", "Gadgets"]},
        {"tags": ["TECH", "Reviews"]},
    ]
    codeflash_output = find_common_tags(articles)  # 542ns -> 1.12μs (51.8% slower)
    # Outputs were verified to be equal to the original implementation


def test_articles_with_non_string_tags():
    # Test with articles having non-string tags
    articles = [
        {"tags": ["python", 123, "coding"]},
        {"tags": ["python", "development", 123]},
        {"tags": ["python", "guide", 123]},
    ]
    codeflash_output = find_common_tags(articles)  # 1.33μs -> 2.71μs (50.7% slower)

    articles = [
        {"tags": [None, "news"]},
        {"tags": ["tech", None]},
        {"tags": [None, "reviews"]},
    ]
    codeflash_output = find_common_tags(articles)  # 792ns -> 1.38μs (42.4% slower)
    # Outputs were verified to be equal to the original implementation


def test_large_scale_test_cases():
    # Test with large scale input where all tags should be common
    articles = [{"tags": ["tag" + str(i) for i in range(1000)]} for _ in range(100)]
    expected_output = {"tag" + str(i) for i in range(1000)}
    codeflash_output = find_common_tags(articles)  # 4.02ms -> 3.94ms (2.00% faster)

    # Test with large scale input where no tags should be common
    articles = [{"tags": ["tag" + str(i) for i in range(1000)]} for _ in range(50)] + [
        {"tags": ["unique_tag"]}
    ]
    codeflash_output = find_common_tags(articles)  # 1.98ms -> 24.0μs (8159% faster)
    # Outputs were verified to be equal to the original implementation

from src.algorithms.string import find_common_tags


def test_find_common_tags():
    find_common_tags([{"\x00\x00\x00\x00": [], "tags": ["", ""]}, {"tags": [""]}])


def test_find_common_tags_2():
    find_common_tags([])


def test_find_common_tags_3():
    find_common_tags([{}, {}])

🔎 Concolic Coverage Tests and Runtime

Test File::Test Function	Original ⏱️	Optimized ⏱️	Speedup
codeflash_concolic_y565j43m/tmpw0d88212/test_concolic_coverage.py::test_find_common_tags	1.04μs	2.25μs	-53.7%⚠️
codeflash_concolic_y565j43m/tmpw0d88212/test_concolic_coverage.py::test_find_common_tags_2	292ns	291ns	0.344%✅
codeflash_concolic_y565j43m/tmpw0d88212/test_concolic_coverage.py::test_find_common_tags_3	1.00μs	1.38μs	-27.3%⚠️

To edit these changes git checkout codeflash/optimize-find_common_tags-mjgw3xzx and push.