Стратегия

from __future__ import annotations
from abc import ABC, abstractmethod
import time


class SortStrategy(ABC):
    @abstractmethod
    def sort(self, data: list) -> list: ...

    @property
    @abstractmethod
    def name(self) -> str: ...


class BubbleSort(SortStrategy):
    @property
    def name(self) -> str:
        return "BubbleSort"

    def sort(self, data: list) -> list:
        # TODO: реализовать сортировку пузырьком
        pass


class QuickSort(SortStrategy):
    @property
    def name(self) -> str:
        return "QuickSort"

    def sort(self, data: list) -> list:
        # TODO: реализовать быструю сортировку (рекурсивно)
        pass


class MergeSort(SortStrategy):
    @property
    def name(self) -> str:
        return "MergeSort"

    def sort(self, data: list) -> list:
        # TODO: реализовать сортировку слиянием
        pass


class Sorter:
    def __init__(self, strategy: SortStrategy) -> None:
        self._strategy = strategy

    def set_strategy(self, strategy: SortStrategy) -> None:
        self._strategy = strategy
        print(f"[Sorter] Стратегия изменена на {strategy.name}")

    def sort(self, data: list) -> list:
        # TODO: выполнить сортировку, вывести название стратегии и время
        pass

    def benchmark(self, data: list,
                  strategies: list[SortStrategy]) -> dict[str, float]:
        # TODO: запустить все стратегии на копии data, вернуть {name: time_ms}
        pass


# Ожидаемый результат:
# data = [64, 34, 25, 12, 22, 11, 90]
# sorter = Sorter(BubbleSort())
# print(sorter.sort(data))   # [11, 12, 22, 25, 34, 64, 90]
# sorter.set_strategy(QuickSort())
# print(sorter.sort(data))   # [11, 12, 22, 25, 34, 64, 90]
# import random
# big = random.sample(range(10000), 1000)
# results = sorter.benchmark(big, [BubbleSort(), QuickSort(), MergeSort()])
# for name, ms in results.items():
#     print(f"{name}: {ms:.2f}ms")

from __future__ import annotations
from abc import ABC, abstractmethod
from dataclasses import dataclass


@dataclass
class CartItem:
    name: str
    price: float
    quantity: int

    @property
    def subtotal(self) -> float:
        return self.price * self.quantity


class DiscountStrategy(ABC):
    @abstractmethod
    def calculate(self, items: list[CartItem],
                  loyalty_points: int = 0) -> float:
        """Вернуть сумму скидки."""
        ...

    @abstractmethod
    def describe(self) -> str: ...


class NoDiscount(DiscountStrategy):
    def calculate(self, items: list[CartItem],
                  loyalty_points: int = 0) -> float:
        return 0.0

    def describe(self) -> str:
        return "Без скидки"


class PercentDiscount(DiscountStrategy):
    def __init__(self, percent: float) -> None:
        self.percent = percent

    def calculate(self, items: list[CartItem],
                  loyalty_points: int = 0) -> float:
        # TODO: процент от общей суммы
        pass

    def describe(self) -> str:
        return f"Скидка {self.percent}%"


class FixedDiscount(DiscountStrategy):
    def __init__(self, amount: float) -> None:
        self.amount = amount

    def calculate(self, items: list[CartItem],
                  loyalty_points: int = 0) -> float:
        # TODO: фиксированная сумма, но не больше итога
        pass

    def describe(self) -> str:
        return f"Скидка -{self.amount}"


class BulkDiscount(DiscountStrategy):
    def __init__(self, min_quantity: int, percent: float) -> None:
        self.min_quantity = min_quantity
        self.percent = percent

    def calculate(self, items: list[CartItem],
                  loyalty_points: int = 0) -> float:
        # TODO: скидка если суммарное кол-во товаров >= min_quantity
        pass

    def describe(self) -> str:
        return f"Скидка {self.percent}% при заказе от {self.min_quantity} шт."


class LoyaltyDiscount(DiscountStrategy):
    POINTS_TO_CURRENCY = 0.01  # 1 балл = 0.01 единицы валюты

    def __init__(self, max_points_to_use: int) -> None:
        self.max_points = max_points_to_use

    def calculate(self, items: list[CartItem],
                  loyalty_points: int = 0) -> float:
        # TODO: использовать min(loyalty_points, max_points) * коэффициент
        pass

    def describe(self) -> str:
        return f"Скидка по баллам лояльности (макс. {self.max_points} баллов)"


class Cart:
    def __init__(self) -> None:
        self._items: list[CartItem] = []
        self._strategy: DiscountStrategy = NoDiscount()
        self.loyalty_points = 0

    def add_item(self, item: CartItem) -> None:
        self._items.append(item)

    def set_strategy(self, strategy: DiscountStrategy) -> None:
        self._strategy = strategy

    def set_best_strategy(self,
                           strategies: list[DiscountStrategy]) -> None:
        # TODO: выбрать стратегию с максимальной скидкой
        pass

    @property
    def subtotal(self) -> float:
        return sum(i.subtotal for i in self._items)

    @property
    def discount(self) -> float:
        return self._strategy.calculate(self._items, self.loyalty_points)

    @property
    def total(self) -> float:
        return max(0.0, self.subtotal - self.discount)

    def receipt(self) -> str:
        lines = [f"  {i.name} x{i.quantity} = {i.subtotal:.2f}"
                 for i in self._items]
        lines.append(f"Подытог: {self.subtotal:.2f}")
        lines.append(f"Скидка ({self._strategy.describe()}): -{self.discount:.2f}")
        lines.append(f"Итого: {self.total:.2f}")
        return "\n".join(lines)


# Ожидаемый результат:
# cart = Cart()
# cart.add_item(CartItem("Apple", 1.0, 10))
# cart.add_item(CartItem("Milk", 2.5, 3))
# cart.loyalty_points = 500
# strategies = [
#     NoDiscount(),
#     PercentDiscount(10),
#     FixedDiscount(3.0),
#     BulkDiscount(min_quantity=10, percent=15),
#     LoyaltyDiscount(max_points_to_use=300),
# ]
# cart.set_best_strategy(strategies)
# print(cart.receipt())

from __future__ import annotations
from abc import ABC, abstractmethod
from dataclasses import dataclass


@dataclass
class ReportRow:
    id: int
    name: str
    value: float
    category: str


class ExportStrategy(ABC):
    @abstractmethod
    def export(self, rows: list[ReportRow], title: str = "Report") -> str: ...

    @property
    @abstractmethod
    def extension(self) -> str: ...


class CsvExporter(ExportStrategy):
    @property
    def extension(self) -> str:
        return "csv"

    def export(self, rows: list[ReportRow], title: str = "Report") -> str:
        # TODO: вернуть CSV-строку с заголовком id,name,value,category
        pass


class JsonExporter(ExportStrategy):
    @property
    def extension(self) -> str:
        return "json"

    def export(self, rows: list[ReportRow], title: str = "Report") -> str:
        # TODO: вернуть JSON {"title": ..., "rows": [...]}
        pass


class XmlExporter(ExportStrategy):
    @property
    def extension(self) -> str:
        return "xml"

    def export(self, rows: list[ReportRow], title: str = "Report") -> str:
        # TODO: вернуть XML-строку
        pass


class MarkdownTableExporter(ExportStrategy):
    @property
    def extension(self) -> str:
        return "md"

    def export(self, rows: list[ReportRow], title: str = "Report") -> str:
        # TODO: вернуть Markdown-таблицу с заголовком ## title
        pass


class ReportExporter:
    def __init__(self, strategy: ExportStrategy) -> None:
        self._strategy = strategy

    def set_strategy(self, strategy: ExportStrategy) -> None:
        self._strategy = strategy

    def export(self, rows: list[ReportRow],
               title: str = "Report") -> str:
        # TODO: делегировать стратегии и вернуть результат
        pass

    def export_all(self, rows: list[ReportRow],
                   strategies: list[ExportStrategy],
                   title: str = "Report") -> dict[str, str]:
        # TODO: вернуть {extension: content} для каждой стратегии
        pass


# Ожидаемый результат:
# rows = [
#     ReportRow(1, "Alice", 1500.0, "Sales"),
#     ReportRow(2, "Bob", 2300.5, "IT"),
#     ReportRow(3, "Carol", 1800.0, "Sales"),
# ]
# exporter = ReportExporter(CsvExporter())
# print(exporter.export(rows, "Q1 Report"))
# # id,name,value,category
# # 1,Alice,1500.0,Sales
# # ...
# exporter.set_strategy(MarkdownTableExporter())
# print(exporter.export(rows, "Q1 Report"))
# results = exporter.export_all(rows, [CsvExporter(), JsonExporter(), XmlExporter()], "Q1")
# print(list(results.keys()))  # ['csv', 'json', 'xml']

from __future__ import annotations
from abc import ABC, abstractmethod
from dataclasses import dataclass
import math


@dataclass(frozen=True)
class Point:
    lat: float
    lon: float
    name: str = ""

    def distance_to(self, other: "Point") -> float:
        """Расстояние в километрах (упрощённая формула)."""
        dlat = (other.lat - self.lat) * 111.0
        dlon = (other.lon - self.lon) * 111.0 * math.cos(math.radians(self.lat))
        return math.sqrt(dlat ** 2 + dlon ** 2)


@dataclass
class Route:
    points: list[Point]
    distance_km: float
    duration_min: float
    description: str


class RoutingStrategy(ABC):
    @abstractmethod
    def build_route(self, origin: Point, destination: Point) -> Route: ...

    @property
    @abstractmethod
    def mode(self) -> str: ...


class CarRoute(RoutingStrategy):
    SPEED_KMH = 60.0

    @property
    def mode(self) -> str:
        return "Автомобиль"

    def build_route(self, origin: Point, destination: Point) -> Route:
        # TODO: прямой маршрут, скорость SPEED_KMH
        pass


class WalkingRoute(RoutingStrategy):
    SPEED_KMH = 5.0

    @property
    def mode(self) -> str:
        return "Пешком"

    def build_route(self, origin: Point, destination: Point) -> Route:
        # TODO: пешеходный маршрут
        pass


class BicycleRoute(RoutingStrategy):
    SPEED_KMH = 15.0

    @property
    def mode(self) -> str:
        return "Велосипед"

    def build_route(self, origin: Point, destination: Point) -> Route:
        # TODO: велосипедный маршрут
        pass


class PublicTransportRoute(RoutingStrategy):
    def __init__(self, stops: list[Point]) -> None:
        self.stops = stops  # промежуточные остановки

    @property
    def mode(self) -> str:
        return "Общественный транспорт"

    def build_route(self, origin: Point, destination: Point) -> Route:
        # TODO: маршрут через stops, скорость 30 км/ч + 5 мин на каждую пересадку
        pass


class Navigator:
    def __init__(self, strategy: RoutingStrategy) -> None:
        self._strategy = strategy

    def set_strategy(self, strategy: RoutingStrategy) -> None:
        self._strategy = strategy
        print(f"[Navigator] Режим: {strategy.mode}")

    def navigate(self, origin: Point, destination: Point) -> Route:
        # TODO: построить маршрут и вывести информацию
        pass

    def compare_routes(self, origin: Point, destination: Point,
                       strategies: list[RoutingStrategy]) -> None:
        # TODO: вывести сравнительную таблицу всех стратегий
        pass


# Ожидаемый результат:
# home = Point(55.751, 37.618, "Дом")
# work = Point(55.796, 37.537, "Работа")
# nav = Navigator(CarRoute())
# route = nav.navigate(home, work)
# print(f"{route.description}: {route.distance_km:.1f} км, {route.duration_min:.0f} мин")
# nav.set_strategy(WalkingRoute())
# nav.compare_routes(home, work, [CarRoute(), WalkingRoute(), BicycleRoute()])