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

Behärska de färdigheter som krävs för att designa, implementera och skala moderna rekommendationsmotorer och transaktionsbaserade associationsmodeller. Gå från att analysera råa butikskvitton med klassiska algoritmiska principer som Apriori och FP-Growth till att bygga avancerade personaliseringssystem med hjälp av kollaborativ filtrering och matrisfaktorisering. Lär dig att konstruera datapipelines som driver moderna digitala butikslager och ökar användarengagemang.

Upptäck hur man hittar dolda samband inom massiva transaktionsdatabaser. Lär dig de grundläggande matematiska ramverken som detaljhandelsjättar använder för att optimera hyllplacering, lagerstrukturer och produktpaketeringsstrategier.

**Vad är den främsta fördelen med FP-Growth jämfört med Apriori?**

Hur komprimerar ett FP-Träd transaktionsdata?

Vilken är en vanlig metod för att filtrera bort mindre användbara regler?

Vilket mått är mest användbart för att identifiera värdefulla produktpaket?

När blir Apriori opraktiskt för stora datamängder?

Vad är en redundant regel inom associationsutvinning?

Ta din algoritmiska kunskap till nästa nivå genom att hantera omfattande företagsdata utan minneskrascher. Behärska högpresterande komprimerade träd och upptäck hur du eliminerar kommersiellt brus från regelmönster.

Få praktisk erfarenhet av att bygga rekommendationsmotorer som driver moderna digitala plattformar. Lär dig att se bortom produktgrupperingar för att kartlägga historiska användarbeteenden, betyg och gemensamma konsumentvanor.

Fördjupa dig i de matematiska grunderna för avancerade maskininlärningsmodeller för glesa datamängder. Lär dig hur man identifierar latenta egenskaper som är dolda i multidimensionella användarfeedbackdata för att noggrant förutsäga saknade interaktioner.

Challenge: Alla Frekventa Objekt

Lösning