
import unittest
import user_code
import ast
import re   
import importlib
import csv
import unittest
import importlib
import pandas as pd

class TestTask(unittest.TestCase):
    def setUp(self):
        self.transactions = pd.DataFrame({
            "user_id": [1, 2, 1, 3, 2, 3, 4, 4, 1],
            "item_id": ["apple", "banana", "banana", "apple", "carrot", "carrot", "apple", "banana", "carrot"]
        })
        self.user_code = importlib.import_module("user_code")

    def test_returns_list_of_length_top_n(self):
        importlib.reload(self.user_code)
        result = self.user_code.customers_also_bought(self.transactions, "apple", top_n=2)
        _dynamic_test(
            self,
            isinstance(result, list) and len(result) == 2,
            "Returns a list of length equal to top_n.",
            f"Returned value is not a list of length 2: {result}"
        )

    def test_does_not_include_self(self):
        importlib.reload(self.user_code)
        result = self.user_code.customers_also_bought(self.transactions, "banana", top_n=2)
        _dynamic_test(
            self,
            "banana" not in result,
            "Does not include the provided item_id in recommendations.",
            f"Recommendations include the provided item_id: {result}"
        )

    def test_similarity_order(self):
        importlib.reload(self.user_code)
        # For 'banana', 'carrot' is most similar, then 'apple'
        result = self.user_code.customers_also_bought(self.transactions, "banana", top_n=2)
        expected_order = ["carrot", "apple"]
        _dynamic_test(
            self,
            result == expected_order,
            "Recommendations are based on highest cosine similarity.",
            f"Expected order {expected_order}, got {result}"
        )

    def test_multiple_occurrences(self):
        importlib.reload(self.user_code)
        # 'apple' appears multiple times; should still recommend correct items
        result = self.user_code.customers_also_bought(self.transactions, "apple", top_n=2)
        _dynamic_test(
            self,
            set(result) == {"banana", "carrot"},
            "Handles cases where the item appears multiple times.",
            f"Expected recommendations {{'banana', 'carrot'}}, got {result}"
        )

    def test_fewer_than_top_n(self):
        importlib.reload(self.user_code)
        # Only two items in this mini-dataset
        df = pd.DataFrame({"user_id": [1, 2, 1, 2], "item_id": ["x", "y", "y", "x"]})
        result = self.user_code.customers_also_bought(df, "x", top_n=5)
        _dynamic_test(
            self,
            isinstance(result, list) and len(result) == 1 and result[0] == "y",
            "Handles cases with fewer than top_n other items.",
            f"Expected ['y'], 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)

def normalize_text(text):
    text = text.lower()
    text = re.sub(r"\\s{2,}", " ", text)
    text = re.sub(r"\\s*([,:?])\\s*", r"\\1 ", text)
    return text.strip()

def change_var(code: str, var_name: str, value: str) -> str:
    tree = ast.parse(code)
    lines = code.splitlines()
    changed = False
    # Collect all assignment nodes to modify
    assign_nodes = [
        (i, node)
        for i, node in enumerate(tree.body)
        if isinstance(node, ast.Assign)
        and any(isinstance(target, ast.Name) and target.id == var_name for target in node.targets)
    ]

    # If nothing to change, return unmodified code
    if not assign_nodes:
        return code

    # Perform replacements for all matching assignments (from last to first to not break line offsets)
    for i, node in reversed(assign_nodes):
        start_line = node.lineno - 1
        line = lines[start_line]
        indent = ' ' * (len(line) - len(line.lstrip()))
        lines[start_line] = f"{indent}{var_name} = {value}"
        next_line = len(lines)
        for next_node in tree.body[i+1:]:
            if hasattr(next_node, 'lineno'):
                next_line = next_node.lineno - 1
                break
        if next_line > start_line + 1:
            lines[start_line+1:next_line] = []
        changed = True

    return '\\n'.join(lines) if changed else code

if __name__ == "__main__":
    unittest.main()


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 diferença entre a filtragem colaborativa baseada em usuários e baseada em itens?

**Qual métrica é melhor para medir similaridade entre vetores de avaliações de usuários?**

Como a filtragem baseada em itens melhora a escalabilidade?

Quando você usaria a correlação de Pearson em vez da similaridade do cosseno?

O que é um vizinho em filtragem colaborativa?

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: Gerando Recomendações de Clientes Também Compraram

Solução