import unittest
import user_code
import importlib

class TestTask(unittest.TestCase):
    def setUp(self):
        import user_code
        importlib.reload(user_code)
        self.user_code = user_code

    def test_basic_frequency(self):
        transactions = [
            ['a', 'b', 'c'],
            ['b', 'c', 'd'],
            ['a', 'b', 'd'],
            ['a', 'c', 'd', 'e'],
            ['a', 'b', 'c', 'd']
        ]
        min_support = 3
        result = self.user_code.find_frequent_single_items(transactions, min_support)
        expected = [('a', 4), ('b', 4), ('c', 4), ('d', 4)]
        _dynamic_test(
            self,
            isinstance(result, list),
            "Returned value is a list",
            f"Returned value is not a list: {type(result)}"
        )
        _dynamic_test(
            self,
            all(isinstance(x, tuple) and len(x) == 2 for x in result),
            "Each element is a tuple (item, support)",
            f"Result contains non-tuple elements: {result}"
        )
        _dynamic_test(
            self,
            sorted(result) == sorted(expected),
            "Correct frequent items for min_support 3",
            f"Expected {expected}, got {result}"
        )

    def test_sorting(self):
        transactions = [
            ['x', 'y', 'z'],
            ['y', 'z'],
            ['x', 'y'],
            ['y'],
            ['x', 'y', 'z']
        ]
        min_support = 2
        result = self.user_code.find_frequent_single_items(transactions, min_support)
        expected = [('y', 5), ('x', 3), ('z', 3)]
        _dynamic_test(
            self,
            result == expected,
            "Items sorted by support desc, then lexicographically",
            f"Expected {expected}, got {result}"
        )

    def test_min_support(self):
        transactions = [
            ['a'],
            ['b'],
            ['c'],
            ['d'],
            ['e']
        ]
        min_support = 1
        result = self.user_code.find_frequent_single_items(transactions, min_support)
        expected = [('a', 1), ('b', 1), ('c', 1), ('d', 1), ('e', 1)]
        _dynamic_test(
            self,
            sorted(result) == sorted(expected),
            "All items returned when min_support is 1",
            f"Expected {expected}, got {result}"
        )

    def test_empty_result(self):
        transactions = [
            ['a', 'b'],
            ['b', 'c'],
            ['c', 'd']
        ]
        min_support = 5
        result = self.user_code.find_frequent_single_items(transactions, min_support)
        _dynamic_test(
            self,
            result == [],
            "Returns empty list if no items meet min_support",
            f"Expected empty list, got {result}"
        )

    def test_sample_dataset(self):
        transactions = [
            ['milk', 'bread', 'eggs'],
            ['bread', 'butter'],
            ['milk', 'bread', 'butter', 'eggs'],
            ['bread', 'eggs'],
            ['milk', 'bread', 'eggs'],
            ['butter', 'eggs'],
            ['milk', 'bread'],
            ['milk', 'eggs'],
            ['bread', 'butter'],
            ['milk', 'bread', 'eggs', 'butter']
        ]
        min_support = 3
        result = self.user_code.find_frequent_single_items(transactions, min_support)
        expected = [('bread', 8), ('eggs', 7), ('milk', 6), ('butter', 5)]
        _dynamic_test(
            self,
            result == expected,
            "Correct frequent items for sample dataset",
            f"Expected {expected}, got {result}"
        )

def _dynamic_test(test_case, condition, success_message, failure_message):
    if condition:
        test_case._testMethodName = success_message
        test_case.assertTrue(True, success_message)
    else:
        test_case._testMethodName = failure_message
        test_case.fail(failure_message)


test_main.py

Domine as habilidades necessárias para projetar, implementar e escalar motores de recomendação modernos e modelos de associação transacional. Progrida desde a análise de registros brutos de vendas no varejo utilizando princípios algorítmicos clássicos como Apriori e FP-Growth até a construção de sistemas avançados de personalização por meio de filtragem colaborativa e fatoração de matrizes. Aprenda a desenvolver pipelines de dados que alimentam camadas de descoberta em vitrines digitais modernas e impulsionam métricas de engajamento do usuário.

Descubra como identificar relações ocultas em grandes estruturas de dados transacionais. Aprenda os principais frameworks matemáticos utilizados por grandes varejistas para otimizar a disposição de prateleiras, estruturas de inventário e estratégias de agrupamento de produtos.

**Qual é a principal vantagem do FP-Growth em relação ao Apriori?**

Como um FP-Tree comprime os dados de transações?

Qual é um método comum para filtrar regras pouco úteis?

Qual métrica é mais útil para identificar pacotes de produtos de alto valor?

Quando o Apriori se torna impraticável para grandes conjuntos de dados?

O que é uma regra redundante em mineração de associação?

Leve seu conhecimento algorítmico ao próximo nível ao lidar com grandes volumes de dados de transações corporativas sem travamentos de memória. Domine árvores comprimidas de alto desempenho e descubra como eliminar ruídos comerciais dos padrões de regras.

Adquira experiência prática na construção de mecanismos de recomendação que impulsionam as plataformas digitais modernas. Aprenda a ir além dos agrupamentos de produtos para mapear comportamentos históricos dos usuários, avaliações e hábitos de consumo compartilhados.

Aprofunde-se nos fundamentos matemáticos de modelos avançados de machine learning para conjuntos de dados esparsos. Aprenda a descobrir características latentes ocultas em dados multidimensionais de feedback de usuários para prever com precisão interações ausentes.

Desafio: Todos os Itens Frequentes

Solução