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

Domina las habilidades necesarias para diseñar, implementar y escalar motores de recomendación modernos y modelos de asociación transaccional. Avanza desde el análisis de compras minoristas en bruto utilizando principios algorítmicos clásicos como Apriori y FP-Growth hasta la construcción de sistemas avanzados de personalización mediante filtrado colaborativo y factorización de matrices. Aprende a diseñar flujos de datos que impulsan las capas de descubrimiento de escaparates digitales modernos y mejoran los indicadores de participación de los usuarios.

Descubra cómo encontrar relaciones ocultas dentro de estructuras masivas de datos transaccionales. Aprenda los marcos matemáticos fundamentales que utilizan los grandes minoristas para optimizar la colocación en estanterías, las estructuras de inventario y las estrategias de agrupación de productos.

**¿Cuál es la principal ventaja de FP-Growth sobre Apriori?**

¿Cómo comprime un FP-Tree los datos de transacciones?

¿Cuál es un método común para filtrar reglas poco útiles?

¿Qué métrica es más útil para identificar paquetes de productos de alto valor?

¿Cuándo se vuelve poco práctico Apriori para conjuntos de datos grandes?

¿Qué es una regla redundante en la minería de asociaciones?

Lleva tu conocimiento algorítmico al siguiente nivel gestionando grandes volúmenes de datos transaccionales corporativos sin fallos de memoria. Domina árboles comprimidos de alto rendimiento y descubre cómo eliminar el ruido comercial de los patrones de reglas.

Adquiera experiencia práctica construyendo los motores de recomendación que impulsan las plataformas digitales modernas. Aprenda a ir más allá de los agrupamientos de productos para mapear comportamientos históricos de los usuarios, calificaciones y hábitos de consumo compartidos.

Sumérgete en los fundamentos matemáticos de modelos avanzados de aprendizaje automático para conjuntos de datos dispersos. Aprende a descubrir características latentes ocultas dentro de datos de retroalimentación de usuarios multidimensionales para predecir con precisión interacciones faltantes.

Challenge: Todos los Ítems Frecuentes

Solución