class IsonoHouse:
    """磯野家のSingletonクラス"""
    _instance = None
    
    def __new__(cls):
        if cls._instance is None:
            cls._instance = super().__new__(cls)
            cls._instance.address = "東京都世田谷区桜新町"
            cls._instance.family_members = ["サザエ", "マスオ", "タラオ", "波平", "フネ", "カツオ", "ワカメ"]
        return cls._instance
    
    def show_family(self):
        print(f"磯野家の住所: {self.address}")
        print(f"家族構成: {', '.join(self.family_members)}")


# 使用例
house1 = IsonoHouse()
house2 = IsonoHouse()

print(f"house1とhouse2は同じインスタンス: {house1 is house2}")  # True
house1.show_family()

from abc import ABC, abstractmethod

# 抽象的な料理クラス
class Dish(ABC):
    @abstractmethod
    def prepare(self):
        pass
    
    @abstractmethod
    def cook(self):
        pass

# 具体的な料理クラス
class Curry(Dish):
    def prepare(self):
        return "野菜とお肉を切ります"
    
    def cook(self):
        return "カレールーで煮込みました！美味しいカレーの完成！"

class Miso_Soup(Dish):
    def prepare(self):
        return "豆腐とワカメを準備します"
    
    def cook(self):
        return "お味噌を溶いて完成！あったかいお味噌汁ができました"

class Hamburg(Dish):
    def prepare(self):
        return "ひき肉をこねてハンバーグの形にします"
    
    def cook(self):
        return "フライパンで焼きました！ジューシーなハンバーグの出来上がり"

# サザエさんの料理工場
class SazaeCookingFactory:
    @staticmethod
    def create_dish(dish_type: str) -> Dish:
        dishes = {
            "カレー": Curry,
            "味噌汁": Miso_Soup,
            "ハンバーグ": Hamburg
        }
        
        dish_class = dishes.get(dish_type)
        if dish_class:
            return dish_class()
        else:
            raise ValueError(f"{dish_type}は作れません...")

# 使用例
print("【今日の夕食作り】")
dinner = SazaeCookingFactory.create_dish("カレー")
print(f"1. {dinner.prepare()}")
print(f"2. {dinner.cook()}")
print()

print("【お味噌汁も作ります】")
soup = SazaeCookingFactory.create_dish("味噌汁")
print(f"1. {soup.prepare()}")
print(f"2. {soup.cook()}")

from typing import List, Protocol

# Observer インターフェース
class FamilyMember(Protocol):
    def update(self, message: str):
        pass

# 具体的なオブザーバー
class Sazae:
    def update(self, message: str):
        print(f"サザエ: 「お父さん、{message}！夕飯できてますよ」")

class Katsuo:
    def update(self, message: str):
        print(f"カツオ: 「おじいちゃん{message}！今日の野球見た？」")

class Wakame:
    def update(self, message: str):
        print(f"ワカメ: 「お父さん{message}♪ お疲れ様です」")

class Fune:
    def update(self, message: str):
        print(f"フネ: 「あなた、{message}。お茶をいれますね」")

# Subject（被観察者）
class Namihei:
    def __init__(self):
        self._observers: List[FamilyMember] = []
    
    def attach(self, observer: FamilyMember):
        """家族メンバーを登録"""
        self._observers.append(observer)
        print(f"{observer.__class__.__name__}が波平さんの帰宅を待っています")
    
    def detach(self, observer: FamilyMember):
        """家族メンバーの登録を解除"""
        self._observers.remove(observer)
    
    def arrive_home(self):
        """帰宅時に全員に通知"""
        print("\n【波平さんが帰宅しました】")
        print("波平: 「ただいま〜！」\n")
        self._notify("お帰りなさい")
    
    def _notify(self, message: str):
        """全オブザーバーに通知"""
        for observer in self._observers:
            observer.update(message)

# 使用例
namihei = Namihei()

# 家族メンバーを登録
sazae = Sazae()
katsuo = Katsuo()
wakame = Wakame()
fune = Fune()

namihei.attach(sazae)
namihei.attach(katsuo)
namihei.attach(wakame)
namihei.attach(fune)

print()
# 波平さんが帰宅
namihei.arrive_home()

from abc import ABC, abstractmethod
from datetime import datetime, timedelta

# 戦略のインターフェース
class HomeworkStrategy(ABC):
    @abstractmethod
    def do_homework(self, subject: str) -> str:
        pass

# 具体的な戦略1: 自分でやる
class SelfStudyStrategy(HomeworkStrategy):
    def do_homework(self, subject: str) -> str:
        return f"よし！{subject}の宿題を自分でやるぞ！時間をかけて丁寧にやろう"

# 具体的な戦略2: 中島くんに聞く
class AskNakajimaStrategy(HomeworkStrategy):
    def do_homework(self, subject: str) -> str:
        return f"中島〜！{subject}の宿題教えてくれよ〜。一緒にやろうぜ！"

# 具体的な戦略3: ワカメに泣きつく
class AskWakameStrategy(HomeworkStrategy):
    def do_homework(self, subject: str) -> str:
        return f"ワカメ〜、お兄ちゃん{subject}の宿題分かんないんだ...ヒントちょうだいよ〜（涙）"

# 具体的な戦略4: 諦める
class GiveUpStrategy(HomeworkStrategy):
    def do_homework(self, subject: str) -> str:
        return f"{subject}の宿題？明日先生に怒られるけど...まあいいや！遊びに行こう！"

# カツオクラス
class Katsuo:
    def __init__(self):
        self.strategy: HomeworkStrategy = None
    
    def set_strategy(self, strategy: HomeworkStrategy):
        """宿題戦略を設定"""
        self.strategy = strategy
    
    def execute_homework(self, subject: str, deadline: datetime):
        """宿題を実行"""
        now = datetime.now()
        time_left = deadline - now
        
        print(f"\n【{subject}の宿題】")
        print(f"締め切りまで: {time_left.days}日")
        
        # 状況に応じて戦略を自動選択
        if time_left.days >= 3:
            self.set_strategy(SelfStudyStrategy())
            print("カツオ: 「まだ時間あるな！」")
        elif time_left.days >= 1:
            self.set_strategy(AskNakajimaStrategy())
            print("カツオ: 「ちょっとヤバいかも...」")
        elif time_left.days == 0 and time_left.seconds > 3600:
            self.set_strategy(AskWakameStrategy())
            print("カツオ: 「やばい！今日中だ！」")
        else:
            self.set_strategy(GiveUpStrategy())
            print("カツオ: 「もう手遅れだ...」")
        
        result = self.strategy.do_homework(subject)
        print(f"カツオ: 「{result}」")

# 使用例
katsuo = Katsuo()

# シナリオ1: 締め切りまで5日
deadline1 = datetime.now() + timedelta(days=5)
katsuo.execute_homework("算数", deadline1)

# シナリオ2: 締め切りまで2日
deadline2 = datetime.now() + timedelta(days=2)
katsuo.execute_homework("国語", deadline2)

# シナリオ3: 締め切り当日
deadline3 = datetime.now() + timedelta(hours=5)
katsuo.execute_homework("理科", deadline3)

from abc import ABC, abstractmethod

# 基本コンポーネント
class Character(ABC):
    @abstractmethod
    def description(self) -> str:
        pass
    
    @abstractmethod
    def warmth_level(self) -> int:
        pass

# 具体的なコンポーネント
class Tarao(Character):
    def description(self) -> str:
        return "タラオちゃん（半袖シャツとズボン）"
    
    def warmth_level(self) -> int:
        return 10  # 基本の暖かさ

# デコレーターの基底クラス
class ClothingDecorator(Character):
    def __init__(self, character: Character):
        self._character = character
    
    @abstractmethod
    def description(self) -> str:
        pass
    
    @abstractmethod
    def warmth_level(self) -> int:
        pass

# 具体的なデコレーター1: 帽子
class Hat(ClothingDecorator):
    def description(self) -> str:
        return f"{self._character.description()} + 黄色い帽子"
    
    def warmth_level(self) -> int:
        return self._character.warmth_level() + 5

# 具体的なデコレーター2: コート
class Coat(ClothingDecorator):
    def description(self) -> str:
        return f"{self._character.description()} + 冬用コート"
    
    def warmth_level(self) -> int:
        return self._character.warmth_level() + 20

# 具体的なデコレーター3: マフラー
class Scarf(ClothingDecorator):
    def description(self) -> str:
        return f"{self._character.description()} + ふわふわマフラー"
    
    def warmth_level(self) -> int:
        return self._character.warmth_level() + 10

# 具体的なデコレーター4: 手袋
class Gloves(ClothingDecorator):
    def description(self) -> str:
        return f"{self._character.description()} + 手袋"
    
    def warmth_level(self) -> int:
        return self._character.warmth_level() + 8

# 使用例
print("【タラオちゃんの着替えタイム】\n")

# 基本のタラオちゃん
tarao = Tarao()
print(f"1. {tarao.description()}")
print(f"   暖かさレベル: {tarao.warmth_level()}\n")

# 帽子を追加
tarao_with_hat = Hat(tarao)
print(f"2. {tarao_with_hat.description()}")
print(f"   暖かさレベル: {tarao_with_hat.warmth_level()}\n")

# さらにマフラーを追加
tarao_with_scarf = Scarf(tarao_with_hat)
print(f"3. {tarao_with_scarf.description()}")
print(f"   暖かさレベル: {tarao_with_scarf.warmth_level()}\n")

# 完全装備（コートと手袋も）
tarao_full = Gloves(Coat(tarao_with_scarf))
print(f"4. {tarao_full.description()}")
print(f"   暖かさレベル: {tarao_full.warmth_level()}")
print("   サザエさん: 「これで公園に行っても大丈夫ですぅ！」")