import java.util.*;
 
// A simple Video class with title
class Video {
    String title;
 
    public Video(String title) {
        this.title = title;
    }
 
    public String getTitle() {
        return title;
    }
}
 
// YouTubePlaylist class holds a list of Video objects
class YouTubePlaylist {
    private List<Video> videos = new ArrayList<>();
 
    // Add a video to the playlist
    public void addVideo(Video video) {
        videos.add(video);
    }
 
    // Expose the video list
    public List<Video> getVideos() {
        return videos;
    }
}
 
// Client Code
class Main {
    public static void main(String[] args) {
        YouTubePlaylist playlist = new YouTubePlaylist();
        playlist.addVideo(new Video("LLD Tutorial"));
        playlist.addVideo(new Video("System Design Basics"));
 
        // Loop through videos and print titles
        for (Video v : playlist.getVideos()) {
            System.out.println(v.getTitle());
        }
    }
}

import java.util.*;
 
// ========== Video class representing a single video ==========
class Video {
    private String title;
 
    public Video(String title) {
        this.title = title;
    }
 
    public String getTitle() {
        return title;
    }
}
 
// ========== YouTubePlaylist class (Aggregate) ==========
class YouTubePlaylist {
    private List<Video> videos = new ArrayList<>();
 
    // Method to add video to playlist
    public void addVideo(Video video) {
        videos.add(video);
    }
 
    // Method to expose internal video list
    public List<Video> getVideos() {
        return videos;
    }
}
 
// ========== Iterator interface ==========
interface PlaylistIterator {
    boolean hasNext();
    Video next();
}
 
// ========== Concrete Iterator class ==========
class YouTubePlaylistIterator implements PlaylistIterator {
    private List<Video> videos;
    private int position;
 
    // Constructor takes the list to iterate on
    public YouTubePlaylistIterator(List<Video> videos) {
        this.videos = videos;
        this.position = 0;
    }
 
    // Check if more videos are left to iterate
    @Override
    public boolean hasNext() {
        return position < videos.size();
    }
 
    // Return the next video in sequence
    @Override
    public Video next() {
        return hasNext() ? videos.get(position++) : null;
    }
}
 
// ========== Main method (Client code) ==========
public class Main {
    public static void main(String[] args) {
        // Create a playlist and add videos
        YouTubePlaylist playlist = new YouTubePlaylist();
        playlist.addVideo(new Video("LLD Tutorial"));
        playlist.addVideo(new Video("System Design Basics"));
 
        // Client directly creates the iterator using internal list (not ideal)
        PlaylistIterator iterator = new YouTubePlaylistIterator(playlist.getVideos());
 
        // Use the iterator to loop through the playlist
        while (iterator.hasNext()) {
            System.out.println(iterator.next().getTitle());
        }
    }
}

import java.util.*;
 
// ========== Video class representing a single video ==========
class Video {
    private String title;
 
    public Video(String title) {
        this.title = title;
    }
 
    public String getTitle() {
        return title;
    }
}
 
// ================ Playlist interface ================
// (acts as a contract for collections that are iterable)
interface Playlist {
    // Method to return an iterator for the collection
    PlaylistIterator createIterator();
}
 
// ========== YouTubePlaylist class (Aggregate) ==========
// Implements Playlist to guarantee it provides an iterator
class YouTubePlaylist implements Playlist {
    private List<Video> videos = new ArrayList<>();
 
    // Method to add a video to the playlist
    public void addVideo(Video video) {
        videos.add(video);
    }
 
    // Instead of exposing the list, return an iterator
    @Override
    public PlaylistIterator createIterator() {
        return new YouTubePlaylistIterator(videos);
    }
}
 
// ========== Iterator interface (defines traversal contract) ==========
interface PlaylistIterator {
    boolean hasNext();   // Checks if more elements are left
    Video next();        // Returns the next element
}
 
// ========== Concrete Iterator class ==========
// Implements the actual logic for traversing the YouTubePlaylist
class YouTubePlaylistIterator implements PlaylistIterator {
    private List<Video> videos;
    private int position;
 
    // Constructor takes the collection to iterate over
    public YouTubePlaylistIterator(List<Video> videos) {
        this.videos = videos;
        this.position = 0;
    }
 
    // Check if more videos are left
    @Override
    public boolean hasNext() {
        return position < videos.size();
    }
 
    // Return the next video in the playlist
    @Override
    public Video next() {
        return hasNext() ? videos.get(position++) : null;
    }
}
 
// ========== Main method (Client code) ==========
public class Main {
    public static void main(String[] args) {
        // Create a playlist and add videos to it
        YouTubePlaylist playlist = new YouTubePlaylist();
        playlist.addVideo(new Video("LLD Tutorial"));
        playlist.addVideo(new Video("System Design Basics"));
 
        // Client simply asks for an iterator — no access to internal data structure
        PlaylistIterator iterator = playlist.createIterator();
 
        // Iterate through the playlist using the provided interface
        while (iterator.hasNext()) {
            System.out.println(iterator.next().getTitle());
        }
    }
}

from __future__ import annotations
from typing import List
 
 
class Video:
    def __init__(self, title: str) -> None:
        self._title = title
 
    @property
    def title(self) -> str:
        return self._title
 
 
class YouTubePlaylistIterator:
    """Concrete Iterator -- implements Python's iterator protocol directly."""
 
    def __init__(self, videos: List[Video]) -> None:
        self._videos = videos
        self._position = 0
 
    def __iter__(self) -> "YouTubePlaylistIterator":
        return self
 
    def __next__(self) -> Video:
        # __next__ raising StopIteration IS hasNext()/next() rolled into one --
        # Python bakes the Iterator Pattern into the language itself.
        if self._position >= len(self._videos):
            raise StopIteration
        video = self._videos[self._position]
        self._position += 1
        return video
 
 
class YouTubePlaylist:
    """Aggregate -- implements __iter__ instead of a createIterator() method."""
 
    def __init__(self) -> None:
        self._videos: List[Video] = []
 
    def add_video(self, video: Video) -> None:
        self._videos.append(video)
 
    def __iter__(self) -> YouTubePlaylistIterator:
        return YouTubePlaylistIterator(self._videos)
 
 
# ── Driver ──────────────────────────────────────────────
if __name__ == "__main__":
    playlist = YouTubePlaylist()
    playlist.add_video(Video("LLD Tutorial"))
    playlist.add_video(Video("System Design Basics"))
 
    # `for video in playlist:` calls __iter__ then __next__ automatically --
    # this IS the Iterator Pattern, already built into the language.
    for video in playlist:
        print(video.title)

import java.util.*;
 
class Main {
    public static void main(String[] args) {
        List<String> fruits = new ArrayList<>();
        fruits.add("Apple");
        fruits.add("Banana");
 
        Iterator<String> iterator = fruits.iterator();
        while (iterator.hasNext()) {
            System.out.println(iterator.next());
        }
    }
}

import java.util.*;
 
class Main {
    public static void main(String[] args) {
        List<Integer> nums = Arrays.asList(10, 20, 30, 40);
 
        // Stream traversal (internally uses a Spliterator)
        nums.stream().forEach(System.out::println);
 
        // Parallel stream traversal (Spliterator can split work across threads).
        // forEachOrdered (not forEach) keeps this demo's output deterministic —
        // forEach would interleave unpredictably across threads.
        nums.parallelStream().forEachOrdered(System.out::println);
    }
}

import java.util.*;
 
class YouTubeChannel {
    public void uploadNewVideo(String videoTitle) {
        // Upload the video
        System.out.println("Uploading: " + videoTitle + "\n");
 
        // Manually notify users
        System.out.println("Sending email to [email protected]");
        System.out.println("Pushing in-app notification to [email protected]");
    }
}
 
class Main {
    public static void main(String[] args) {
        // Create a channel and upload a new video
        YouTubeChannel channel = new YouTubeChannel();
        channel.uploadNewVideo("Design Patterns in Java");
    }
}

import java.util.*;
 
// ==============================
// Observer Interface
// ==============================
interface Subscriber {
    void update(String videoTitle);
}
 
// ==============================
// Concrete Observer: Email
// ==============================
class EmailSubscriber implements Subscriber {
    private String email;
 
    public EmailSubscriber(String email) {
        this.email = email;
    }
 
    @Override
    public void update(String videoTitle) {
        System.out.println("Email sent to " + email + ": New video uploaded - " + videoTitle);
    }
}
 
// ==============================
// Concrete Observer: Mobile App
// ==============================
class MobileAppSubscriber implements Subscriber {
    private String username;
 
    public MobileAppSubscriber(String username) {
        this.username = username;
    }
 
    @Override
    public void update(String videoTitle) {
        System.out.println("In-app notification for " + username + ": New video - " + videoTitle);
    }
}
 
// ==============================
// Subject Interface
// ==============================
interface Channel {
    void subscribe(Subscriber subscriber);
    void unsubscribe(Subscriber subscriber);
    void notifySubscribers(String videoTitle);
}
 
// ==============================
// Concrete Subject: YouTubeChannel
// ==============================
class YouTubeChannel implements Channel {
    private List<Subscriber> subscribers = new ArrayList<>();
    private String channelName;
 
    public YouTubeChannel(String channelName) {
        this.channelName = channelName;
    }
 
    @Override
    public void subscribe(Subscriber subscriber) {
        subscribers.add(subscriber);
    }
 
    @Override
    public void unsubscribe(Subscriber subscriber) {
        subscribers.remove(subscriber);
    }
 
    @Override
    public void notifySubscribers(String videoTitle) {
        for (Subscriber subscriber : subscribers) {
            subscriber.update(videoTitle);
        }
    }
 
    // Simulates video upload and triggers notifications
    public void uploadVideo(String videoTitle) {
        System.out.println(channelName + " uploaded: " + videoTitle + "\n");
        notifySubscribers(videoTitle);
    }
}
 
// ==============================
// Client Code
// ==============================
class Main {
    public static void main(String[] args) {
        YouTubeChannel channel = new YouTubeChannel("techchannel");
 
        // Add subscribers
        channel.subscribe(new MobileAppSubscriber("alex"));
        channel.subscribe(new EmailSubscriber("[email protected]"));
 
        // Upload video and notify all observers
        channel.uploadVideo("observer-pattern");
    }
}

from __future__ import annotations
from abc import ABC, abstractmethod
from typing import List
 
 
class Subscriber(ABC):
    # Java's `interface` has no direct Python counterpart with a compiler-
    # enforced contract; abc.ABC + @abstractmethod makes the contract
    # explicit and fails fast if a concrete subscriber forgets update().
    @abstractmethod
    def update(self, video_title: str) -> None: ...
 
 
class EmailSubscriber(Subscriber):
    def __init__(self, email: str) -> None:
        self._email = email
 
    def update(self, video_title: str) -> None:
        print(f"Email sent to {self._email}: New video uploaded - {video_title}")
 
 
class MobileAppSubscriber(Subscriber):
    def __init__(self, username: str) -> None:
        self._username = username
 
    def update(self, video_title: str) -> None:
        print(f"In-app notification for {self._username}: New video - {video_title}")
 
 
class YouTubeChannel:
    def __init__(self, channel_name: str) -> None:
        self._channel_name = channel_name
        self._subscribers: List[Subscriber] = []
 
    def subscribe(self, subscriber: Subscriber) -> None:
        self._subscribers.append(subscriber)
 
    def unsubscribe(self, subscriber: Subscriber) -> None:
        self._subscribers.remove(subscriber)
 
    def notify_subscribers(self, video_title: str) -> None:
        for subscriber in self._subscribers:
            subscriber.update(video_title)
 
    def upload_video(self, video_title: str) -> None:
        print(f"{self._channel_name} uploaded: {video_title}\n")
        self.notify_subscribers(video_title)
 
 
# ── Driver ──────────────────────────────────────────────
if __name__ == "__main__":
    channel = YouTubeChannel("techchannel")
 
    channel.subscribe(MobileAppSubscriber("alex"))
    channel.subscribe(EmailSubscriber("[email protected]"))
 
    channel.upload_video("observer-pattern")

import java.util.*;
 
// Class implementing Ride Matching Service
class RideMatchingService {
    public void matchRider(String riderLocation, String matchingType) {
        // Match rider using different hardcoded strategies
        if (matchingType.equals("NEAREST")) {
            // Find nearest driver
            System.out.println("Matching rider at " + riderLocation + " with nearest driver.");
        } else if (matchingType.equals("SURGE_PRIORITY")) {
            // Match based on surge area logic
            System.out.println("Matching rider at " + riderLocation + " based on surge pricing priority.");
        } else if (matchingType.equals("AIRPORT_QUEUE")) {
            // Use FIFO-based airport queue logic
            System.out.println("Matching rider at " + riderLocation + " from airport queue.");
        } else {
            System.out.println("Invalid matching strategy provided.");
        }
    }
}
 
// Client Code
public class Main {
    public static void main(String[] args) {
        RideMatchingService service = new RideMatchingService();
 
        // Try different strategies
        service.matchRider("Downtown", "NEAREST");
        service.matchRider("City Center", "SURGE_PRIORITY");
        service.matchRider("Airport Terminal 1", "AIRPORT_QUEUE");
    }
}

import java.util.*;
 
// ==============================
// Strategy Interface
// ==============================
interface MatchingStrategy {
    void match(String riderLocation);
}
 
// ==============================
// Concrete Strategy: Nearest Driver
// ==============================
class NearestDriverStrategy implements MatchingStrategy {
    @Override
    public void match(String riderLocation) {
        System.out.println("Matching with the nearest available driver to " + riderLocation);
        // Distance-based matching logic
    }
}
 
// ==============================
// Concrete Strategy: Airport Queue
// ==============================
class AirportQueueStrategy implements MatchingStrategy {
    @Override
    public void match(String riderLocation) {
        System.out.println("Matching using FIFO airport queue for " + riderLocation);
        // Match first-in-line driver for airport pickup
    }
}
 
// ==============================
// Concrete Strategy: Surge Priority
// ==============================
class SurgePriorityStrategy implements MatchingStrategy {
    @Override
    public void match(String riderLocation) {
        System.out.println("Matching rider using surge pricing priority near " + riderLocation);
        // Prioritize high-surge zones or premium drivers
    }
}
 
// ==============================
// Context Class: RideMatchingService
// ==============================
class RideMatchingService {
    private MatchingStrategy strategy;
 
    // Constructor injection of strategy
    public RideMatchingService(MatchingStrategy strategy) {
        this.strategy = strategy;
    }
 
    // Setter injection for changing strategy dynamically
    public void setStrategy(MatchingStrategy strategy) {
        this.strategy = strategy;
    }
 
    // Delegates the matching logic to the strategy
    public void matchRider(String location) {
        strategy.match(location);
    }
}
 
// ==============================
// Client Code
// ==============================
public class Main {
    public static void main(String[] args) {
        // Using airport queue strategy
        RideMatchingService rideMatchingService = new RideMatchingService(new AirportQueueStrategy());
        rideMatchingService.matchRider("Terminal 1");
 
        // Using nearest driver strategy and later switching to surge priority
        RideMatchingService rideMatchingService2 = new RideMatchingService(new NearestDriverStrategy());
        rideMatchingService2.matchRider("Downtown");
        rideMatchingService2.setStrategy(new SurgePriorityStrategy());
        rideMatchingService2.matchRider("Downtown");
    }
}

from __future__ import annotations
from abc import ABC, abstractmethod
 
 
class MatchingStrategy(ABC):
    @abstractmethod
    def match(self, rider_location: str) -> None: ...
 
 
class NearestDriverStrategy(MatchingStrategy):
    def match(self, rider_location: str) -> None:
        print(f"Matching with the nearest available driver to {rider_location}")
 
 
class AirportQueueStrategy(MatchingStrategy):
    def match(self, rider_location: str) -> None:
        print(f"Matching using FIFO airport queue for {rider_location}")
 
 
class SurgePriorityStrategy(MatchingStrategy):
    def match(self, rider_location: str) -> None:
        print(f"Matching rider using surge pricing priority near {rider_location}")
 
 
class RideMatchingService:
    # Python's first-class functions mean a plain function or lambda would
    # often be enough here (e.g. self._strategy = lambda loc: print(...));
    # the class-based form below mirrors the Java structure one-to-one.
    def __init__(self, strategy: MatchingStrategy) -> None:
        self._strategy = strategy
 
    def set_strategy(self, strategy: MatchingStrategy) -> None:
        self._strategy = strategy
 
    def match_rider(self, location: str) -> None:
        self._strategy.match(location)
 
 
# ── Driver ──────────────────────────────────────────────
if __name__ == "__main__":
    service = RideMatchingService(AirportQueueStrategy())
    service.match_rider("Terminal 1")
 
    service2 = RideMatchingService(NearestDriverStrategy())
    service2.match_rider("Downtown")
    service2.set_strategy(SurgePriorityStrategy())
    service2.match_rider("Downtown")

import java.util.*;
 
// Receiver classes - Light and AC with basic on/off methods
class Light {
    public void on() {
        System.out.println("Light turned ON");
    }
 
    public void off() {
        System.out.println("Light turned OFF");
    }
}
 
class AC {
    public void on() {
        System.out.println("AC turned ON");
    }
 
    public void off() {
        System.out.println("AC turned OFF");
    }
}
 
// Invoker - NaiveRemoteControl class to control devices
class NaiveRemoteControl {
    private Light light;
    private AC ac;
    private String lastAction = "";
 
    public NaiveRemoteControl(Light light, AC ac) {
        this.light = light;
        this.ac = ac;
    }
 
    // Command methods
    public void pressLightOn() {
        light.on();
        lastAction = "LIGHT_ON";
    }
 
    public void pressLightOff() {
        light.off();
        lastAction = "LIGHT_OFF";
    }
 
    public void pressACOn() {
        ac.on();
        lastAction = "AC_ON";
    }
 
    public void pressACOff() {
        ac.off();
        lastAction = "AC_OFF";
    }
 
    // Undo last action
    public void pressUndo() {
        switch (lastAction) {
            case "LIGHT_ON": light.off(); lastAction = "LIGHT_OFF"; break;
            case "LIGHT_OFF": light.on(); lastAction = "LIGHT_ON"; break;
            case "AC_ON": ac.off(); lastAction = "AC_OFF"; break;
            case "AC_OFF": ac.on(); lastAction = "AC_ON"; break;
            default: System.out.println("No action to undo."); break;
        }
    }
}
 
// Client Code
public class Main {
    public static void main(String[] args) {
        Light light = new Light();
        AC ac = new AC();
        NaiveRemoteControl remote = new NaiveRemoteControl(light, ac);
 
        remote.pressLightOn();
        remote.pressACOn();
        remote.pressLightOff();
        remote.pressUndo(); // Should undo LIGHT_OFF -> Light ON
        remote.pressUndo(); // Should undo AC_ON -> AC OFF
    }
}

import java.util.*;
 
// ========= Receiver classes ===========
// Light and AC with basic on/off methods
class Light {
    public void on() {
        System.out.println("Light turned ON");
    }
 
    public void off() {
        System.out.println("Light turned OFF");
    }
}
 
class AC {
    public void on() {
        System.out.println("AC turned ON");
    }
 
    public void off() {
        System.out.println("AC turned OFF");
    }
}
 
// ========= Command interface ===========
//    defines the command structure
interface Command {
    void execute();
    void undo();
}
 
// Concrete commands for Light ON and OFF
class LightOnCommand implements Command {
    private Light light;
 
    public LightOnCommand(Light light) {
        this.light = light;
    }
 
    public void execute() {
        light.on();
    }
 
    public void undo() {
        light.off();
    }
}
 
class LightOffCommand implements Command {
    private Light light;
 
    public LightOffCommand(Light light) {
        this.light = light;
    }
 
    public void execute() {
        light.off();
    }
 
    public void undo() {
        light.on();
    }
}
 
// Concrete commands for AC ON and OFF
class AConCommand implements Command {
    private AC ac;
 
    public AConCommand(AC ac) {
        this.ac = ac;
    }
 
    public void execute() {
        ac.on();
    }
 
    public void undo() {
        ac.off();
    }
}
 
class ACOffCommand implements Command {
    private AC ac;
 
    public ACOffCommand(AC ac) {
        this.ac = ac;
    }
 
    public void execute() {
        ac.off();
    }
 
    public void undo() {
        ac.on();
    }
}
 
// ========== Remote control class (Invoker) ==========
class RemoteControl {
    private Command[] buttons = new Command[4];  // Assigning 4 slots for commands
    private Stack<Command> commandHistory = new Stack<>();
 
    // Assign command to slot
    public void setCommand(int slot, Command command) {
        buttons[slot] = command;
    }
 
    // Press the button to execute the command
    public void pressButton(int slot) {
        if (buttons[slot] != null) {
            buttons[slot].execute();
            commandHistory.push(buttons[slot]);
        } else {
            System.out.println("No command assigned to slot " + slot);
        }
    }
 
    // Undo the last action
    public void pressUndo() {
        if (!commandHistory.isEmpty()) {
            commandHistory.pop().undo();
        } else {
            System.out.println("No commands to undo.");
        }
    }
}
 
// ========= Client code ===========
public class Main {
    public static void main(String[] args) {
        Light light = new Light();
        AC ac = new AC();
 
        Command lightOn = new LightOnCommand(light);
        Command lightOff = new LightOffCommand(light);
        Command acOn = new AConCommand(ac);
        Command acOff = new ACOffCommand(ac);
 
        RemoteControl remote = new RemoteControl();
        remote.setCommand(0, lightOn);
        remote.setCommand(1, lightOff);
        remote.setCommand(2, acOn);
        remote.setCommand(3, acOff);
 
        remote.pressButton(0); // Light ON
        remote.pressButton(2); // AC ON
        remote.pressButton(1); // Light OFF
        remote.pressUndo();    // Undo Light OFF -> Light ON
        remote.pressUndo();    // Undo AC ON -> AC OFF
    }
}

from __future__ import annotations
from abc import ABC, abstractmethod
from typing import List, Optional
 
 
class Light:
    def on(self) -> None:
        print("Light turned ON")
 
    def off(self) -> None:
        print("Light turned OFF")
 
 
class AC:
    def on(self) -> None:
        print("AC turned ON")
 
    def off(self) -> None:
        print("AC turned OFF")
 
 
class Command(ABC):
    @abstractmethod
    def execute(self) -> None: ...
 
    @abstractmethod
    def undo(self) -> None: ...
 
 
class LightOnCommand(Command):
    def __init__(self, light: Light) -> None:
        self._light = light
 
    def execute(self) -> None:
        self._light.on()
 
    def undo(self) -> None:
        self._light.off()
 
 
class LightOffCommand(Command):
    def __init__(self, light: Light) -> None:
        self._light = light
 
    def execute(self) -> None:
        self._light.off()
 
    def undo(self) -> None:
        self._light.on()
 
 
class ACOnCommand(Command):
    def __init__(self, ac: AC) -> None:
        self._ac = ac
 
    def execute(self) -> None:
        self._ac.on()
 
    def undo(self) -> None:
        self._ac.off()
 
 
class ACOffCommand(Command):
    def __init__(self, ac: AC) -> None:
        self._ac = ac
 
    def execute(self) -> None:
        self._ac.off()
 
    def undo(self) -> None:
        self._ac.on()
 
 
class RemoteControl:
    # A plain function/lambda could stand in for each Command here too
    # (Python has first-class functions); the class-based form is kept for
    # structural parity with the Java, and because undo() needs state
    # (which device, which prior action) that a bare lambda would lose.
    def __init__(self) -> None:
        self._buttons: List[Optional[Command]] = [None] * 4
        self._history: List[Command] = []
 
    def set_command(self, slot: int, command: Command) -> None:
        self._buttons[slot] = command
 
    def press_button(self, slot: int) -> None:
        command = self._buttons[slot]
        if command is not None:
            command.execute()
            self._history.append(command)
        else:
            print(f"No command assigned to slot {slot}")
 
    def press_undo(self) -> None:
        if self._history:
            self._history.pop().undo()
        else:
            print("No commands to undo.")
 
 
# ── Driver ──────────────────────────────────────────────
if __name__ == "__main__":
    light = Light()
    ac = AC()
 
    remote = RemoteControl()
    remote.set_command(0, LightOnCommand(light))
    remote.set_command(1, LightOffCommand(light))
    remote.set_command(2, ACOnCommand(ac))
    remote.set_command(3, ACOffCommand(ac))
 
    remote.press_button(0)   # Light ON
    remote.press_button(2)   # AC ON
    remote.press_button(1)   # Light OFF
    remote.press_undo()      # Undo Light OFF -> Light ON
    remote.press_undo()      # Undo AC ON -> AC OFF

import java.util.*;
 
// EmailNotification handles sending emails
class EmailNotification {
 
    public void send(String to, String message) {
        System.out.println("Checking rate limits for: " + to);
        System.out.println("Validating email recipient: " + to);
        String formatted = message.trim();
        System.out.println("Logging before send: " + formatted + " to " + to);
 
        // Compose Email
        String composedMessage = "<html><body><p>" + formatted + "</p></body></html>";
 
        // Send Email
        System.out.println("Sending EMAIL to " + to + " with content:\n" + composedMessage);
 
        // Analytics
        System.out.println("Analytics updated for: " + to);
    }
}
 
// SMSNotification handles sending SMS messages
class SMSNotification {
 
    public void send(String to, String message) {
        System.out.println("Checking rate limits for: " + to);
        System.out.println("Validating phone number: " + to);
        String formatted = message.trim();
        System.out.println("Logging before send: " + formatted + " to " + to);
 
        // Compose SMS
        String composedMessage = "[SMS] " + formatted;
 
        // Send SMS
        System.out.println("Sending SMS to " + to + " with message: " + composedMessage);
 
        // Analytics (custom)
        System.out.println("Custom SMS analytics for: " + to);
    }
}
 
class Main {
    public static void main(String[] args) {
        // Create objects for both notification services
        EmailNotification emailNotification = new EmailNotification();
        SMSNotification smsNotification = new SMSNotification();
 
        // Sending email notification
        emailNotification.send("[email protected]", "Your order has been placed!");
 
        System.out.println(" ");
 
        // Sending SMS notification
        smsNotification.send("1234567890", "Your OTP is 1234.");
    }
}

import java.util.*;
 
// Abstract class defining the template method and common steps
abstract class NotificationSender {
 
    // Template method
    public final void send(String to, String rawMessage) {
        // Common Logic
        rateLimitCheck(to);
        validateRecipient(to);
        String formatted = formatMessage(rawMessage);
        preSendAuditLog(to, formatted);
 
        // Specific Logic: defined by subclassese
        String composedMessage = composeMessage(formatted);
        sendMessage(to, composedMessage);
 
        // Optional Hook
        postSendAnalytics(to);
    }
 
    // Common step 1: Check rate limits
    private void rateLimitCheck(String to) {
        System.out.println("Checking rate limits for: " + to);
    }
 
    // Common step 2: Validate recipient
    private void validateRecipient(String to) {
        System.out.println("Validating recipient: " + to);
    }
 
    // Common step 3: Format the message (can be customized)
    private String formatMessage(String message) {
        return message.trim(); // could include HTML escaping, emoji processing, etc.
    }
 
    // Common step 4: Pre-send audit log
    private void preSendAuditLog(String to, String formatted) {
        System.out.println("Logging before send: " + formatted + " to " + to);
    }
 
    // Hook for subclasses to implement custom message composition
    protected abstract String composeMessage(String formattedMessage);
 
    // Hook for subclasses to implement custom message sending
    protected abstract void sendMessage(String to, String message);
 
    // Optional hook for analytics (can be overridden)
    protected void postSendAnalytics(String to) {
        System.out.println("Analytics updated for: " + to);
    }
}
 
// Concrete class for email notifications
class EmailNotification extends NotificationSender {
 
    // Implement message composition for email
    @Override
    protected String composeMessage(String formattedMessage) {
        return "<html><body><p>" + formattedMessage + "</p></body></html>";
    }
 
    // Implement email sending logic
    @Override
    protected void sendMessage(String to, String message) {
        System.out.println("Sending EMAIL to " + to + " with content:\n" + message);
    }
}
 
// Concrete class for SMS notifications
class SMSNotification extends NotificationSender {
 
    // Implement message composition for SMS
    @Override
    protected String composeMessage(String formattedMessage) {
        return "[SMS] " + formattedMessage;
    }
 
    // Implement SMS sending logic
    @Override
    protected void sendMessage(String to, String message) {
        System.out.println("Sending SMS to " + to + " with message: " + message);
    }
 
    // Override optional hook for custom SMS analytics
    @Override
    protected void postSendAnalytics(String to) {
        System.out.println("Custom SMS analytics for: " + to);
    }
}
 
// Client code
class Main {
    public static void main(String[] args) {
        NotificationSender emailSender = new EmailNotification();
        emailSender.send("[email protected]", "Welcome to the platform!");
 
        System.out.println(" ");
 
        NotificationSender smsSender = new SMSNotification();
        smsSender.send("9876543210", "Your OTP is 4567.");
    }
}

from __future__ import annotations
from abc import ABC, abstractmethod
 
 
class NotificationSender(ABC):
    # `send` is Java's `final` template method -- Python has no `final`
    # keyword, so nothing stops a subclass from overriding send() itself;
    # sealing the algorithm's shape is a convention here, not a
    # compiler-enforced guarantee the way Java's `final` seals it.
    def send(self, to: str, raw_message: str) -> None:
        self._rate_limit_check(to)
        self._validate_recipient(to)
        formatted = self._format_message(raw_message)
        self._pre_send_audit_log(to, formatted)
 
        composed_message = self.compose_message(formatted)
        self.send_message(to, composed_message)
 
        self.post_send_analytics(to)
 
    def _rate_limit_check(self, to: str) -> None:
        print(f"Checking rate limits for: {to}")
 
    def _validate_recipient(self, to: str) -> None:
        print(f"Validating recipient: {to}")
 
    def _format_message(self, message: str) -> str:
        return message.strip()
 
    def _pre_send_audit_log(self, to: str, formatted: str) -> None:
        print(f"Logging before send: {formatted} to {to}")
 
    @abstractmethod
    def compose_message(self, formatted_message: str) -> str: ...
 
    @abstractmethod
    def send_message(self, to: str, message: str) -> None: ...
 
    def post_send_analytics(self, to: str) -> None:
        # Optional hook -- default behaviour, overridable by subclasses.
        print(f"Analytics updated for: {to}")
 
 
class EmailNotification(NotificationSender):
    def compose_message(self, formatted_message: str) -> str:
        return f"<html><body><p>{formatted_message}</p></body></html>"
 
    def send_message(self, to: str, message: str) -> None:
        print(f"Sending EMAIL to {to} with content:\n{message}")
 
 
class SMSNotification(NotificationSender):
    def compose_message(self, formatted_message: str) -> str:
        return f"[SMS] {formatted_message}"
 
    def send_message(self, to: str, message: str) -> None:
        print(f"Sending SMS to {to} with message: {message}")
 
    def post_send_analytics(self, to: str) -> None:
        print(f"Custom SMS analytics for: {to}")
 
 
# ── Driver ──────────────────────────────────────────────
if __name__ == "__main__":
    email_sender = EmailNotification()
    email_sender.send("[email protected]", "Welcome to the platform!")
 
    print(" ")
 
    sms_sender = SMSNotification()
    sms_sender.send("9876543210", "Your OTP is 4567.")

import java.util.*;
 
class Order {
    private String state;
 
    // Constructor initializes the state to ORDER_PLACED
    public Order() {
        this.state = "ORDER_PLACED";
    }
 
    // Method to cancel the order
    // only allows cancellation if in ORDER_PLACED or PREPARING states
    public void cancelOrder() {
        if (state.equals("ORDER_PLACED") || state.equals("PREPARING")) {
            state = "CANCELLED";
            System.out.println("Order has been cancelled.");
        } else {
            System.out.println("Cannot cancel the order now.");
        }
    }
 
    // Method to move the order to the next state based on its current state
    public void nextState() {
        switch (state) {
            case "ORDER_PLACED":
                state = "PREPARING";
                break;
            case "PREPARING":
                state = "OUT_FOR_DELIVERY";
                break;
            case "OUT_FOR_DELIVERY":
                state = "DELIVERED";
                break;
            default:
                System.out.println("No next state from: " + state);
                return;
        }
        System.out.println("Order moved to: " + state);
    }
 
    // Getter for the state
    public String getState() {
        return state;
    }
}
 
class Main {
    // Main method to test the order flow
    public static void main(String[] args) {
        Order order = new Order();
 
        // Display initial state
        System.out.println("Initial State: " + order.getState());
 
        // Moving through states
        order.nextState(); // ORDER_PLACED -> PREPARING
        order.nextState(); // PREPARING -> OUT_FOR_DELIVERY
        order.nextState(); // OUT_FOR_DELIVERY -> DELIVERED
 
        // Attempting to cancel an order after it is out for delivery
        order.cancelOrder(); // Should not allow cancellation
 
        // Display final state
        System.out.println("Final State: " + order.getState());
    }
}

import java.util.*;
 
// OrderContext class manages the current state of the order
class OrderContext {
    private OrderState currentState;
 
    // Constructor initializes the state to ORDER_PLACED
    public OrderContext() {
        this.currentState = new OrderPlacedState(); // default state
    }
 
    // Method to set a new state for the order
    public void setState(OrderState state) {
        this.currentState = state;
    }
 
    // Method to move the order to the next state
    public void next() {
        currentState.next(this);
    }
 
    // Method to cancel the order
    public void cancel() {
        currentState.cancel(this);
    }
 
    // Method to get the current state of the order
    public String getCurrentState() {
        return currentState.getStateName();
    }
}
 
// OrderState interface defines the behavior of the order states
interface OrderState {
    void next(OrderContext context); // Move to the next state
    void cancel(OrderContext context); // Cancel the order
    String getStateName(); // Get the name of the state
}
 
// Concrete states for each stage of the order
 
// OrderPlacedState handles the behavior when the order is placed
class OrderPlacedState implements OrderState {
    public void next(OrderContext context) {
        context.setState(new PreparingState());
        System.out.println("Order is now being prepared.");
    }
 
    public void cancel(OrderContext context) {
        context.setState(new CancelledState());
        System.out.println("Order has been cancelled.");
    }
 
    public String getStateName() {
        return "ORDER_PLACED";
    }
}
 
// PreparingState handles the behavior when the order is being prepared
class PreparingState implements OrderState {
    public void next(OrderContext context) {
        context.setState(new OutForDeliveryState());
        System.out.println("Order is out for delivery.");
    }
 
    public void cancel(OrderContext context) {
        context.setState(new CancelledState());
        System.out.println("Order has been cancelled.");
    }
 
    public String getStateName() {
        return "PREPARING";
    }
}
 
// OutForDeliveryState handles the behavior when the order is out for delivery
class OutForDeliveryState implements OrderState {
    public void next(OrderContext context) {
        context.setState(new DeliveredState());
        System.out.println("Order has been delivered.");
    }
 
    public void cancel(OrderContext context) {
        System.out.println("Cannot cancel. Order is out for delivery.");
    }
 
    public String getStateName() {
        return "OUT_FOR_DELIVERY";
    }
}
 
// DeliveredState handles the behavior when the order is delivered
class DeliveredState implements OrderState {
    public void next(OrderContext context) {
        System.out.println("Order is already delivered.");
    }
 
    public void cancel(OrderContext context) {
        System.out.println("Cannot cancel a delivered order.");
    }
 
    public String getStateName() {
        return "DELIVERED";
    }
}
 
// CancelledState handles the behavior when the order is cancelled
class CancelledState implements OrderState {
    public void next(OrderContext context) {
        System.out.println("Cancelled order cannot move to next state.");
    }
 
    public void cancel(OrderContext context) {
        System.out.println("Order is already cancelled.");
    }
 
    public String getStateName() {
        return "CANCELLED";
    }
}
 
public class Main {
    public static void main(String[] args) {
        OrderContext order = new OrderContext();
 
        // Display initial state
        System.out.println("Current State: " + order.getCurrentState());
 
        // Moving through states
        order.next();  // ORDER_PLACED -> PREPARING
        order.next();  // PREPARING -> OUT_FOR_DELIVERY
        order.cancel(); // Should fail, as order is out for delivery
        order.next();  // OUT_FOR_DELIVERY -> DELIVERED
        order.cancel(); // Should fail, as order is delivered
 
        // Display final state
        System.out.println("Final State: " + order.getCurrentState());
    }
}

from __future__ import annotations
from abc import ABC, abstractmethod
 
 
class OrderState(ABC):
    @abstractmethod
    def next(self, context: "OrderContext") -> None: ...
 
    @abstractmethod
    def cancel(self, context: "OrderContext") -> None: ...
 
    @abstractmethod
    def state_name(self) -> str: ...
 
 
class OrderPlacedState(OrderState):
    def next(self, context: "OrderContext") -> None:
        context.set_state(PreparingState())
        print("Order is now being prepared.")
 
    def cancel(self, context: "OrderContext") -> None:
        context.set_state(CancelledState())
        print("Order has been cancelled.")
 
    def state_name(self) -> str:
        return "ORDER_PLACED"
 
 
class PreparingState(OrderState):
    def next(self, context: "OrderContext") -> None:
        context.set_state(OutForDeliveryState())
        print("Order is out for delivery.")
 
    def cancel(self, context: "OrderContext") -> None:
        context.set_state(CancelledState())
        print("Order has been cancelled.")
 
    def state_name(self) -> str:
        return "PREPARING"
 
 
class OutForDeliveryState(OrderState):
    def next(self, context: "OrderContext") -> None:
        context.set_state(DeliveredState())
        print("Order has been delivered.")
 
    def cancel(self, context: "OrderContext") -> None:
        print("Cannot cancel. Order is out for delivery.")
 
    def state_name(self) -> str:
        return "OUT_FOR_DELIVERY"
 
 
class DeliveredState(OrderState):
    def next(self, context: "OrderContext") -> None:
        print("Order is already delivered.")
 
    def cancel(self, context: "OrderContext") -> None:
        print("Cannot cancel a delivered order.")
 
    def state_name(self) -> str:
        return "DELIVERED"
 
 
class CancelledState(OrderState):
    def next(self, context: "OrderContext") -> None:
        print("Cancelled order cannot move to next state.")
 
    def cancel(self, context: "OrderContext") -> None:
        print("Order is already cancelled.")
 
    def state_name(self) -> str:
        return "CANCELLED"
 
 
class OrderContext:
    def __init__(self) -> None:
        self._current_state: OrderState = OrderPlacedState()
 
    def set_state(self, state: OrderState) -> None:
        self._current_state = state
 
    def next(self) -> None:
        self._current_state.next(self)
 
    def cancel(self) -> None:
        self._current_state.cancel(self)
 
    @property
    def current_state(self) -> str:
        return self._current_state.state_name()
 
 
# ── Driver ──────────────────────────────────────────────
if __name__ == "__main__":
    order = OrderContext()
 
    print(f"Current State: {order.current_state}")
 
    order.next()     # ORDER_PLACED -> PREPARING
    order.next()     # PREPARING -> OUT_FOR_DELIVERY
    order.cancel()   # Should fail, order is out for delivery
    order.next()     # OUT_FOR_DELIVERY -> DELIVERED
    order.cancel()   # Should fail, order is delivered
 
    print(f"Final State: {order.current_state}")

import java.util.*;
 
// SupportService class: Handles different types of support requests
class SupportService {
 
    // Method to handle the support request based on the type of issue
    public void handleRequest(String type) {
        if (type.equals("general")) {
            System.out.println("Handled by General Support");
        } else if (type.equals("refund")) {
            System.out.println("Handled by Billing Team");
        } else if (type.equals("technical")) {
            System.out.println("Handled by Technical Support");
        } else if (type.equals("delivery")) {
            System.out.println("Handled by Delivery Team");
        } else {
            System.out.println("No handler available");
        }
    }
}
 
// Main class: Entry point to test the chain of responsibility pattern
public class Main {
 
    public static void main(String[] args) {
        // Create an instance of SupportService
        SupportService supportService = new SupportService();
 
        // Test with different types of requests
        supportService.handleRequest("general");
        supportService.handleRequest("refund");
        supportService.handleRequest("technical");
        supportService.handleRequest("delivery");
        supportService.handleRequest("unknown");
    }
}

import java.util.*;
 
// Abstract class defining the SupportHandler
abstract class SupportHandler {
    protected SupportHandler nextHandler;
 
    // Method to set the next handler in the chain
    public void setNextHandler(SupportHandler nextHandler) {
        this.nextHandler = nextHandler;
    }
 
    // Abstract method to handle the request
    public abstract void handleRequest(String requestType);
}
 
// Concrete Handler for General Support
class GeneralSupport extends SupportHandler {
    public void handleRequest(String requestType) {
        if (requestType.equalsIgnoreCase("general")) {
            System.out.println("GeneralSupport: Handling general query");
        } else if (nextHandler != null) {
            nextHandler.handleRequest(requestType);
        }
    }
}
 
// Concrete Handler for Billing Support
class BillingSupport extends SupportHandler {
    public void handleRequest(String requestType) {
        if (requestType.equalsIgnoreCase("refund")) {
            System.out.println("BillingSupport: Handling refund request");
        } else if (nextHandler != null) {
            nextHandler.handleRequest(requestType);
        }
    }
}
 
// Concrete Handler for Technical Support
class TechnicalSupport extends SupportHandler {
    public void handleRequest(String requestType) {
        if (requestType.equalsIgnoreCase("technical")) {
            System.out.println("TechnicalSupport: Handling technical issue");
        } else if (nextHandler != null) {
            nextHandler.handleRequest(requestType);
        }
    }
}
 
// Concrete Handler for Delivery Support
class DeliverySupport extends SupportHandler {
    public void handleRequest(String requestType) {
        if (requestType.equalsIgnoreCase("delivery")) {
            System.out.println("DeliverySupport: Handling delivery issue");
        } else if (nextHandler != null) {
            nextHandler.handleRequest(requestType);
        } else {
            System.out.println("DeliverySupport: No handler found for request");
        }
    }
}
 
// Client Code
class Main {
    public static void main(String[] args) {
        SupportHandler general = new GeneralSupport();
        SupportHandler billing = new BillingSupport();
        SupportHandler technical = new TechnicalSupport();
        SupportHandler delivery = new DeliverySupport();
 
        // Setting up the chain: general -> billing -> technical -> delivery
        general.setNextHandler(billing);
        billing.setNextHandler(technical);
        technical.setNextHandler(delivery);
 
        // Testing the chain of responsibility with different request types
        general.handleRequest("refund");
        general.handleRequest("delivery");
        general.handleRequest("unknown");
    }
}