CTO Challenge 2016 2nd LV3

coupon_selector.py

from typing import List, Dict
from functools import reduce
from collections import Counter
from menu import Menu

Coupon = int


class CouponSelector():
    def __init__(self,
                 limitation_of_coupons: Dict[Coupon, int],
                 coupons_available_for_pizza: List[Coupon],
                 lowest_amount_for_using_coupon: int
                 ) -> None:
        self.limitation_of_coupons = limitation_of_coupons
        self.coupons_available_for_pizza = coupons_available_for_pizza
        self.lowest_amount_for_using_coupon = lowest_amount_for_using_coupon

    def select_optimum_combination_by_menus(
            self,
            menus: List[Menu],
            coupons: List[Coupon]):

        amount = reduce(lambda amount, m: amount + m.price, menus, 0)
        available_coupons = _filter_limited_coupons(
            coupons,
            self.limitation_of_coupons
        )
        if not _pizza_exists(menus):
            available_coupons = [c for c in available_coupons
                                 if c not in self.coupons_available_for_pizza]
        return self.select_optimum_combination(amount, available_coupons)

    def select_optimum_combination(self, amount: int, coupons: List[Coupon]):
        if amount <= self.lowest_amount_for_using_coupon:
            return []
        sorted_coupons = sorted(coupons, reverse=True)
        rest = amount
        used_coupons = []
        for c in sorted_coupons:
            if rest < c:
                break
            rest -= c
            used_coupons.append(c)

        return used_coupons


def _pizza_exists(menus: List[Menu]):
    return any(m.is_pizza() for m in menus)


def _filter_limited_coupons(
        coupons: List[Coupon],
        coupon2limit: Dict[Coupon, int]):
    counter = Counter(coupons)
    for c, n in counter.items():
        counter[c] = min(coupon2limit[c], n)
    return list(counter.elements())

lv1_test.py

from coupon_selector import CouponSelector

coupon_selector = CouponSelector({}, [], 1000)


def test_select_optimum_combination_case1():
    selected = coupon_selector.select_optimum_combination(
        1000,
        [500, 500, 200, 100, 100, 100]
    )
    assert selected == []


def test_select_optimum_combination_case2():
    selected = coupon_selector.select_optimum_combination(1210, [])
    assert selected == []


def test_select_optimum_combination_case3():
    selected = coupon_selector.select_optimum_combination(
        1210,
        [500, 500, 200, 100, 100, 100]
    )
    assert selected == [500, 500, 200]


def test_select_optimum_combination_case4():
    selected = coupon_selector.select_optimum_combination(
        1530,
        [500, 500, 200, 100, 100, 100]
    )
    assert selected == [500, 500, 200, 100, 100, 100]


def test_discounted_in_order_when_coupons_are_not_sorted():
    selected = coupon_selector.select_optimum_combination(
        1530,
        [500, 200, 100, 500, 100, 100]
    )
    assert selected == [500, 500, 200, 100, 100, 100]

lv2_test.py

from coupon_selector import CouponSelector
from menu import PizzaMenu, SideMenu

coupon_selector = CouponSelector(
    {500: 2, 200: 2, 100: 3, 400: 1},
    [400],
    1000
)


def test_select_optimum_combination_by_menu_case1_on_lv2():
    menus = [PizzaMenu("ジェノベーゼ", "M", 1000)]
    selected = coupon_selector.select_optimum_combination_by_menus(
        menus,
        [500, 200, 100, 400]
    )
    assert selected == []


def test_select_optimum_combination_by_menu_case2_on_lv2():
    menus = [PizzaMenu("マルゲリータ", "M", 1200)]
    selected = coupon_selector.select_optimum_combination_by_menus(
        menus,
        []
    )
    assert selected == []


def test_select_optimum_combination_by_menu_case3_on_lv2():
    menus = [
        SideMenu("ポテトフライ", 400),
        SideMenu("ポテトフライ", 400),
        SideMenu("シーザーサラダ", 600)
    ]
    selected = coupon_selector.select_optimum_combination_by_menus(
        menus,
        [500, 500, 200, 100, 100, 400]
    )
    assert selected == [500, 500, 200, 100, 100]


def test_select_optimum_combination_by_menu_case4_on_lv2():
    menus = [PizzaMenu("ジェノベーゼ", "L", 1400)]
    selected = coupon_selector.select_optimum_combination_by_menus(
        menus,
        [500, 500, 200, 100, 100, 400]
    )
    assert selected == [500, 500, 400]


def test_select_optimum_combination_by_menu_case5_on_lv2():
    menus = [PizzaMenu("ジェノベーゼ", "M", 1000), PizzaMenu("マルゲリータ", "M", 1200)]
    selected = coupon_selector.select_optimum_combination_by_menus(
        menus,
        [500, 500, 500, 200, 200, 200, 100, 100, 100, 100, 400, 400]
    )
    assert selected == [500, 500, 400, 200, 200, 100, 100, 100]

lv3_test.py

from itertools import combinations, product
from datetime import datetime
from setmenu_discounter import SetMenuDiscount, SetMenuDiscounter
from menu import PizzaMenu, SideMenu


all_pizza = [
    PizzaMenu("ジェノベーゼ", "M", 1000),
    PizzaMenu("マルゲリータ", "M", 1200),
    PizzaMenu("ジェノベーゼ", "L", 1400),
    PizzaMenu("マルゲリータ", "L", 1800),
]

l_pizza = [
    PizzaMenu("ジェノベーゼ", "L", 1400),
    PizzaMenu("マルゲリータ", "L", 1800),
]

side_menus = [
    SideMenu("ポテトフライ", 400),
    SideMenu("グリーンサラダ", 500),
    SideMenu("シーザーサラダ", 600)
]


def is_weekday_and_from_11_to_14(d):
    return 0 <= d.weekday() and \
        d.weekday() < 5 and \
        11 <= d.hour and \
        d.hour <= 14

service = SetMenuDiscounter([
    SetMenuDiscount(
        "ピザ2セット",
        list(map(lambda x: list(x), combinations(all_pizza, 2))),
        None,
        [SideMenu("ポテトフライ", 400)],
        None
    ),
    SetMenuDiscount(
        "ピザL2セット",
        list(map(lambda x: list(x), combinations(l_pizza, 2))),
        None,
        [
            SideMenu("ポテトフライ", 400),
            SideMenu("グリーンサラダ", 500),
            SideMenu("シーザーサラダ", 600)
        ],
        None
    ),
    SetMenuDiscount(
        "平日ランチセット",
        list(map(lambda x: list(x), product(all_pizza, side_menus))),
        [is_weekday_and_from_11_to_14],
        [],
        400
    )
])


def test_pizza2_set():
    orders = [
        PizzaMenu("ジェノベーゼ", "M", 1000),
        PizzaMenu("マルゲリータ", "M", 1200),
        SideMenu("ポテトフライ", 400),
    ]
    (actual, discount) = service.decide_discount(orders, datetime.now())
    assert type(actual) == SetMenuDiscount
    assert actual.name == "ピザ2セット"
    assert discount == 400


def test_pizzaL2_set():
    orders = [
        PizzaMenu("ジェノベーゼ", "L", 1400),
        PizzaMenu("マルゲリータ", "L", 1800),
        SideMenu("グリーンサラダ", 500),
    ]
    (actual, discount) = service.decide_discount(orders, datetime.now())
    assert type(actual) == SetMenuDiscount
    assert actual.name == "ピザL2セット"
    assert discount == 500


def test_weekday_lunch_set():
    orders = [
        PizzaMenu("ジェノベーゼ", "L", 1400),
        SideMenu("グリーンサラダ", 500),
    ]
    (actual, discount) = service.decide_discount(
        orders,
        datetime(2016, 10, 26, 11, 30, 0)
    )
    assert type(actual) == SetMenuDiscount
    assert actual.name == "平日ランチセット"
    assert discount == 400

Makefile

pip=bin/pip
python=bin/python
pyflakes=bin/pyflakes
pytest=bin/pytest

run: $(python)
	$< main.py -c $(cs) -m $(ms)

test: $(pytest)
	$< -v ./lv1_test.py ./lv2_test.py ./lv3_test.py

install: $(pip)
	$< install -r requirements.txt

$(pytest): $(pip)
	$(MAKE) install

$(pyflakes): $(pip)
	$(MAKE) install

$(python): 
	virtualenv . -p python3

$(pip): 
	virtualenv . -p python3

clean:
	rm -rf ./bin
	rm -rf ./lib
	rm -rf ./include

menu.py

from typing import Dict, List, Tuple


class Menu(object):
    def __init__(self, name, price):
        self.name = name
        self.price = price

    def __eq__(self, other):
        return self.name == other.name

    def __ne__(self, other):
        return not self.__eq__(other)

    def __hash__(self):
        return hash(str(self))

    def __str__(self):
        return self.name

    def is_pizza(self):
        return type(self) == PizzaMenu


class PizzaMenu(Menu):
    def __init__(self, name, size, price):
        super(PizzaMenu, self).__init__(name, price)
        self.size = size

    def __str__(self):
        return str(self.name + self.size)


class SideMenu(Menu):
    def __init__(self, name, price):
        super(SideMenu, self).__init__(name, price)


class MenuRepository():
    def __init__(self, master: Dict[str, Menu] = {}) -> None:
        self.master = master

    def find_by_name(self, name: str) -> Menu:
        return self.master.get(name, None)


class OrderService():
    def __init__(self, menu_repository: MenuRepository) -> None:
        self.menu_repository = menu_repository

    def order(self, menu_names: List[str]) -> Tuple[List[Menu], List[str]]:
        menus = []
        not_found_menus = []
        for name in menu_names:
            menu = self.menu_repository.find_by_name(name)
            if menu is not None:
                menus.append(menu)
            else:
                not_found_menus.append(name)
        return (menus, not_found_menus)

requirements.txt

pytest
flake8
mypy-lang

setmenu_discounter.py

from datetime import datetime
from typing import List, Tuple, Callable
from menu import Menu


class SetMenuDiscount(object):
    def __init__(self, name: str,
                 required_menus_combinations: List[List[Menu]],
                 available_time_rules: List[Callable[[datetime], bool]],
                 discount_target_menus: List[Menu],
                 discount: int = None)->None:
        self.name = name
        self.required_menus_combinations = required_menus_combinations
        self.available_time_rules = available_time_rules
        self.discount_target_menus = discount_target_menus
        self.discount = discount

    def is_available(self, ordered_menus: List[Menu],
                     ordered_time: datetime)->bool:
        return self.in_available_period(ordered_time) \
            and self.is_matched(ordered_menus)

    def is_matched(self, ordered_menus: List[Menu])->bool:
        ordered_menu_set = set(ordered_menus)
        for combination in self.required_menus_combinations:
            c = set(combination)
            if c.intersection(ordered_menu_set) == c:
                return True
        return False

    def in_available_period(self, ordered_time: datetime)->bool:
        if self.available_time_rules is None:
            return True
        return any(map(lambda fn: fn(ordered_time), self.available_time_rules))

    def get_target_discount_menus(self, ordered_menus: List[Menu])->List[Menu]:
        t = set(self.discount_target_menus).intersection(set(ordered_menus))
        return list(t)

    def has_amount_discounts(self)->bool:
        return self.discount is not None

    def has_menu_discounts(self)->bool:
        return len(self.discount_target_menus) > 0

    def calculate_discount(self, ordered_menus: List[Menu])->int:
        price = 0
        if self.has_menu_discounts():
            menus = self.get_target_discount_menus(ordered_menus)
            prices = map(lambda m: m.price, menus)
            m = max(prices, default=0)
            price = max(price, m)
        if self.has_amount_discounts():
            price = max(price, self.discount)
        return price


class SetMenuDiscounter():
    def __init__(self, discounts: List[SetMenuDiscount])->None:
        self.discounts = discounts

    def decide_discount(self,
                        ordered: List[Menu],
                        current_time: datetime
                        )->Tuple[SetMenuDiscount, int]:

        availables = [d for d in self.discounts
                      if d.is_available(ordered, current_time)]
        if not availables:
            return (None, 0)

        best, *rest = availables
        best_discount = best.calculate_discount(ordered)
        for d in rest:
            p = d.calculate_discount(ordered)
            if best_discount < p:
                best = d
                best_discount = p
        return (best, best_discount)