Practice Questions — Inheritance and Polymorphism

class Shape:
    def area(self):
        return 0
    
    def __str__(self):
        return f"{type(self).__name__}: {self.area()}"

class Circle(Shape):
    def __init__(self, radius):
        self.radius = radius
    def area(self):
        return round(3.14159 * self.radius ** 2, 2)

class Rectangle(Shape):
    def __init__(self, width, height):
        self.width = width
        self.height = height
    def area(self):
        return self.width * self.height

class Triangle(Shape):
    def __init__(self, base, height):
        self.base = base
        self.height = height
    def area(self):
        return 0.5 * self.base * self.height

def total_area(shapes):
    return sum(s.area() for s in shapes)

shapes = [Circle(5), Rectangle(4, 6), Triangle(6, 4)]
for s in shapes:
    print(s)
print(f"Total: {total_area(shapes)}")

class Employee:
    def __init__(self, name, base_salary):
        self.name = name
        self.base_salary = base_salary
    
    def calculate_pay(self):
        return self.base_salary
    
    def role(self):
        return type(self).__name__

class Manager(Employee):
    def __init__(self, name, base_salary, bonus):
        super().__init__(name, base_salary)
        self.bonus = bonus
    
    def calculate_pay(self):
        return self.base_salary + self.bonus

class Developer(Employee):
    def __init__(self, name, base_salary, overtime_hours):
        super().__init__(name, base_salary)
        self.overtime_hours = overtime_hours
    
    def calculate_pay(self):
        return self.base_salary + self.overtime_hours * 500

class Intern(Employee):
    def calculate_pay(self):
        return int(self.base_salary * 0.5)

team = [Manager("Aarav", 50000, 10000), Developer("Priya", 40000, 10), Intern("Rohan", 20000)]
total = 0
for emp in team:
    pay = emp.calculate_pay()
    total += pay
    print(f"{emp.name} ({emp.role()}): Rs.{pay}")
print(f"Total payroll: Rs.{total}")

class Animal:
    def __init__(self, name):
        self.name = name
    def sound(self):
        return "..."
    def __str__(self):
        return f"{self.name} the {type(self).__name__} says: {self.sound()}"

class Dog(Animal):
    def sound(self): return "Woof!"

class Cat(Animal):
    def sound(self): return "Meow!"

class Cow(Animal):
    def sound(self): return "Moo!"

class Duck(Animal):
    def sound(self): return "Quack!"

class Robot:  # Not an Animal!
    def __init__(self, name):
        self.name = name
    def sound(self):
        return "Beep!"
    def __str__(self):
        return f"{self.name} the Robot says: {self.sound()}"

def animal_chorus(things):
    for thing in things:
        print(thing)

animal_chorus([Dog("Rex"), Cat("Luna"), Cow("Gauri"), Duck("Daisy"), Robot("R2D2")])

class Student:
    def __init__(self, name, gpa):
        self.name = name
        self.gpa = gpa
    
    def __lt__(self, other):
        return self.gpa < other.gpa
    
    def __eq__(self, other):
        return isinstance(other, Student) and self.gpa == other.gpa
    
    def __str__(self):
        return f"{self.name} (GPA: {self.gpa})"
    
    def __repr__(self):
        return f"Student('{self.name}', {self.gpa})"

students = [
    Student("Aarav", 9.2),
    Student("Priya", 9.8),
    Student("Rohan", 7.9),
    Student("Meera", 8.5),
]

sorted_students = sorted(students, reverse=True)
print("Sorted by GPA (desc):")
for i, s in enumerate(sorted_students, 1):
    print(f"{i}. {s}")

from abc import ABC, abstractmethod

class Plugin(ABC):
    @abstractmethod
    def name(self): pass
    
    @abstractmethod
    def version(self): pass
    
    @abstractmethod
    def execute(self, data): pass

class UpperCasePlugin(Plugin):
    def name(self): return "UpperCase"
    def version(self): return "1.0"
    def execute(self, data): return data.upper()

class ReversePlugin(Plugin):
    def name(self): return "Reverse"
    def version(self): return "1.0"
    def execute(self, data): return data[::-1]

class CountPlugin(Plugin):
    def name(self): return "Counter"
    def version(self): return "1.0"
    def execute(self, data): return f"{len(data)} characters"

class PluginManager:
    def __init__(self):
        self.plugins = []
    
    def register(self, plugin):
        self.plugins.append(plugin)
    
    def run_all(self, data):
        for plugin in self.plugins:
            result = plugin.execute(data)
            print(f"Running {plugin.name()} v{plugin.version()}: {result}")

pm = PluginManager()
pm.register(UpperCasePlugin())
pm.register(ReversePlugin())
pm.register(CountPlugin())
pm.run_all("hello world")

class A:
    def who_am_i(self):
        return "A"

class B(A):
    def who_am_i(self):
        return "B -> " + super().who_am_i()

class C(A):
    def who_am_i(self):
        return "C -> " + super().who_am_i()

class D(B, C):
    def who_am_i(self):
        return "D -> " + super().who_am_i()

d = D()
mro_names = [cls.__name__ for cls in D.__mro__]
print(f"MRO: {' -> '.join(mro_names)}")
print(d.who_am_i())

from abc import ABC, abstractmethod

class TimestampMixin:
    def timestamped_str(self):
        return f"[2026-04-06] {str(self)}"

class SerializableMixin:
    def to_dict(self):
        return {k: v for k, v in self.__dict__.items() if not k.startswith('_')}

class ValidatableMixin(ABC):
    @abstractmethod
    def validate(self):
        pass

class User(TimestampMixin, SerializableMixin, ValidatableMixin):
    def __init__(self, name, age):
        self.name = name
        self.age = age
    
    def validate(self):
        errors = []
        if not self.name or not self.name.strip():
            errors.append("Name cannot be empty")
        if not isinstance(self.age, int) or self.age < 0 or self.age > 150:
            errors.append("Age must be between 0 and 150")
        return (len(errors) == 0, errors)
    
    def __str__(self):
        return f"User: {self.name}, {self.age}"

u1 = User("Aarav", 16)
print(u1.timestamped_str())
print(u1.to_dict())
valid, errors = u1.validate()
print(f"Valid: {valid}")

u2 = User("", 16)
valid, errors = u2.validate()
print(f"Invalid name: {errors[0]}")

u3 = User("Rohan", 200)
valid, errors = u3.validate()
print(f"Invalid age: {errors[0]}")

class SortedList:
    def __init__(self, items=None):
        self._data = sorted(items) if items else []
    
    def insert(self, value):
        for i, item in enumerate(self._data):
            if value <= item:
                self._data.insert(i, value)
                return
        self._data.append(value)
    
    def __len__(self):
        return len(self._data)
    
    def __getitem__(self, index):
        return self._data[index]
    
    def __contains__(self, value):
        for item in self._data:
            if item == value:
                return True
            if item > value:
                return False
        return False
    
    def __add__(self, other):
        return SortedList(self._data + other._data)
    
    def __eq__(self, other):
        return isinstance(other, SortedList) and self._data == other._data
    
    def __iter__(self):
        return iter(self._data)
    
    def __str__(self):
        return f"SortedList({self._data})"

s1 = SortedList([5, 1, 9, 3, 7])
print(s1)
print(f"Length: {len(s1)}")
print(f"Index 2: {s1[2]}")
print(f"5 in list: {5 in s1}")

s2 = SortedList([2, 4, 6])
merged = s1 + s2
print(f"Merged: {merged}")