# Creating an array (bookshelf) in Python
bookshelf = ["Harry Potter", "Lord of the Rings", "Pride and Prejudice", "1984", "To Kill a Mockingbird"]


# Accessing elements
print(bookshelf[0])  # Output: Harry Potter
print(bookshelf[2])  # Output: Pride and Prejudice


# Modifying an element
bookshelf[1] = "The Hobbit"
print(bookshelf)  # Output: ['Harry Potter', 'The Hobbit', 'Pride and Prejudice', '1984', 'To Kill a Mockingbird']

class Node:
    def __init__(self, data):
        self.data = data
        self.next = None


class LinkedList:
    def __init__(self):
        self.head = None


    def append(self, data):
        new_node = Node(data)
        if not self.head:
            self.head = new_node
            return
        last_node = self.head
        while last_node.next:
            last_node = last_node.next
        last_node.next = new_node


    def display(self):
        current = self.head
        while current:
            print(current.data, end=" -> ")
            current = current.next
        print("None")


# Creating a linked list
train = LinkedList()
train.append("Engine")
train.append("Passenger Car")
train.append("Dining Car")
train.append("Cargo Car")


train.display()  # Output: Engine -> Passenger Car -> Dining Car -> Cargo Car -> None

class BrowserHistory:
    def __init__(self):
        self.history = []


    def visit(self, url):
        self.history.append(url)
        print(f"Visited: {url}")


    def back(self):
        if len(self.history) > 1:
            self.history.pop()
            print(f"Went back to: {self.history[-1]}")
        else:
            print("Can't go back further!")


# Using our browser history stack
browser = BrowserHistory()
browser.visit("google.com")
browser.visit("youtube.com")
browser.visit("github.com")
browser.back()
browser.back()
browser.back()
browser.back()


# Output:
# Visited: google.com
# Visited: youtube.com
# Visited: github.com
# Went back to: youtube.com
# Went back to: google.com
# Can't go back further!

from collections import deque


class PrinterQueue:
    def __init__(self):
        self.queue = deque()


    def add_job(self, document):
        self.queue.append(document)
        print(f"Added '{document}' to the print queue")


    def print_job(self):
        if self.queue:
            document = self.queue.popleft()
            print(f"Printing: {document}")
        else:
            print("No jobs in the queue")


    def display_queue(self):
        print("Current queue:", list(self.queue))


# Using our printer queue
printer = PrinterQueue()
printer.add_job("Annual Report")
printer.add_job("Meeting Minutes")
printer.add_job("Employee Handbook")
printer.display_queue()
printer.print_job()
printer.print_job()
printer.display_queue()


# Output:
# Added 'Annual Report' to the print queue
# Added 'Meeting Minutes' to the print queue
# Added 'Employee Handbook' to the print queue
# Current queue: ['Annual Report', 'Meeting Minutes', 'Employee Handbook']
# Printing: Annual Report
# Printing: Meeting Minutes
# Current queue: ['Employee Handbook']

class SimpleHashTable:
    def __init__(self, size):
        self.size = size
        self.table = [[] for _ in range(self.size)]


    def _hash(self, key):
        return sum(ord(char) for char in key) % self.size


    def insert(self, key, value):
        index = self._hash(key)
        for item in self.table[index]:
            if item[0] == key:
                item[1] = value
                return
        self.table[index].append([key, value])


    def get(self, key):
        index = self._hash(key)
        for item in self.table[index]:
            if item[0] == key:
                return item[1]
        raise KeyError(key)


    def display(self):
        for i, bucket in enumerate(self.table):
            print(f"Bucket {i}: {bucket}")


# Using our simple hash table
library = SimpleHashTable(10)
library.insert("Moby Dick", "Shelf A")
library.insert("Pride and Prejudice", "Shelf B")
library.insert("The Great Gatsby", "Shelf C")
library.insert("To Kill a Mockingbird", "Shelf D")


library.display()
print("Location of 'The Great Gatsby':", library.get("The Great Gatsby"))


# Output might look like:
# Bucket 0: []
# Bucket 1: []
# Bucket 2: [['Moby Dick', 'Shelf A']]
# Bucket 3: []
# Bucket 4: [['Pride and Prejudice', 'Shelf B']]
# Bucket 5: [['The Great Gatsby', 'Shelf C']]
# Bucket 6: []
# Bucket 7: [['To Kill a Mockingbird', 'Shelf D']]
# Bucket 8: []
# Bucket 9: []
# Location of 'The Great Gatsby': Shelf C

class FamilyMember:
    def __init__(self, name):
        self.name = name
        self.children = []


    def add_child(self, child):
        self.children.append(child)


    def display(self, level=0):
        print("  " * level + self.name)
        for child in self.children:
            child.display(level + 1)


# Creating a family tree
grandparent = FamilyMember("Grandparent")
parent1 = FamilyMember("Parent 1")
parent2 = FamilyMember("Parent 2")
child1 = FamilyMember("Child 1")
child2 = FamilyMember("Child 2")
grandchild1 = FamilyMember("Grandchild 1")


grandparent.add_child(parent1)
grandparent.add_child(parent2)
parent1.add_child(child1)
parent1.add_child(child2)
child1.add_child(grandchild1)


# Displaying the family tree
grandparent.display()


# Output:
# Grandparent
#   Parent 1
#     Child 1
#       Grandchild 1
#     Child 2
#   Parent 2

class SocialNetwork:
    def __init__(self):
        self.network = {}


    def add_person(self, name):
        if name not in self.network:
            self.network[name] = set()


    def add_friendship(self, person1, person2):
        self.add_person(person1)
        self.add_person(person2)
        self.network[person1].add(person2)
        self.network[person2].add(person1)


    def display_network(self):
        for person, friends in self.network.items():
            print(f"{person}: {', '.join(friends)}")


# Creating a social network
social_net = SocialNetwork()
social_net.add_friendship("Alice", "Bob")
social_net.add_friendship("Alice", "Charlie")
social_net.add_friendship("Bob", "David")
social_net.add_friendship("Charlie", "David")
social_net.add_friendship("Eve", "Alice")


social_net.display_network()


# Output:
# Alice: Bob, Charlie, Eve
# Bob: Alice, David
# Charlie: Alice, David
# David: Bob, Charlie
# Eve: Alice

import heapq


class EmergencyRoom:
    def __init__(self):
        self.patients = []
        self.patient_count = 0


    def add_patient(self, name, priority):
        # We use negative priority for max heap behavior
        heapq.heappush(self.patients, (-priority, self.patient_count, name))
        self.patient_count += 1
        print(f"Patient {name} added with priority {priority}")


    def treat_next_patient(self):
        if self.patients:
            _, _, name = heapq.heappop(self.patients)
            print(f"Treating patient: {name}")
        else:
            print("No patients in waiting.")


    def display_queue(self):
        print("Current queue (Higher number means higher priority):")
        sorted_patients = sorted(self.patients)
        for priority, _, name in sorted_patients:
            print(f"  {name}: Priority {-priority}")


# Using our emergency room
er = EmergencyRoom()
er.add_patient("John", 3)
er.add_patient("Alice", 5)
er.add_patient("Bob", 1)
er.add_patient("Eve", 4)


er.display_queue()
er.treat_next_patient()
er.treat_next_patient()
er.display_queue()


# Output:
# Patient John added with priority 3
# Patient Alice added with priority 5
# Patient Bob added with priority 1
# Patient Eve added with priority 4
# Current queue (Higher number means higher priority):
#   Alice: Priority 5
#   Eve: Priority 4
#   John: Priority 3
#   Bob: Priority 1
# Treating patient: Alice
# Treating patient: Eve
# Current queue (Higher number means higher priority):
#   John: Priority 3
#   Bob: Priority 1