A: "Given a whole number (an integer), determine the previous and next whole numbers."
B: "Given the width and height of a right triangle, determine the area of the shape. (Area of a right triangle = 0.5 * width * height)"
C: "Given the cost of an order, the tip percentage, and the tax percentage, calculate the total amount to be paid."

A: "Given an integer NUM, determine the previous and next integers.",
B: "Given the values WIDTH and HEIGHT of a right triangle, calculate the area of the shape. (Area of a right triangle = 0.5 * width * height)",
C: "Given the cost of an order , the tip percentage , and the tax percentage , calculate the total amount to be paid.",

def greetPerson(name, age):
    return f"{name} is {age} years old."

A: name = 'John Doe'
   age = 37"
B: name = 'Jane Doe'
   age = 35"

def add_by_twos():
    total = 0
    for i in range(5):
        total = total + 2
    return total

A: "What does" add_by_twos() "return?"
B: "If we changed" range(5) "to" range(3)", what would the function return?"
C: "If we changed" total + 2 "to" total + 3", what would the original function return?"
                                

A: "Ready to eat"
B: "Keep cooking"
C: "Ready to eat"

def grade_letter(score):
    if score >= 90:
        return "A"
    elif score >= 80:
        return "B"
    elif score >= 70:
        return "C"
    elif score >= 60:
        return "D"
    else:
        return "F"

A: grade_letter(85)
B: grade_letter(92)
C: grade_letter(58)
D: grade_letter(70)

def get_student_info(students, grades):
    first_student = students[0]
    last_grade = grades[2]
    total_students = len(students)
    return f"{first_student} and there are {total_students} students"

A: get_student_info(['Alice', 'Bob', 'Charlie'], [85, 90, 78])
B: get_student_info(['Emma', 'David'], [92, 88, 95])
C: "What would" grades[1] "return from the first example?"
D: "What would" len(['x', 'y', 'z', 'w']) "return?"

public class BankAccount {
    private double balance;
    private String accountNumber;
    
    public BankAccount(String accountNumber, double initialBalance) {
        this.accountNumber = accountNumber;
        this.balance = initialBalance;
    }
    
    public void deposit(double amount) {
        if (amount > 0) {
            balance += amount;
        }
    }

    public boolean withdraw(double amount) {
        if (amount > 0 && amount <= balance) {
            balance -= amount;
            return true;
        }
        return false;
    }
    
    public double getBalance() {
        return balance;
    }
}

A: "Why doesn't this class have a" setBalance() "method?"
B: "What happens if you try to deposit a negative amount?"
C: "What does the withdraw method return if you try to withdraw more money than the balance?"
D: "How does this class demonstrate the principle of encapsulation?"

public class Vehicle {
    protected String brand;
    protected int year;
        
    public Vehicle(String brand, int year) {
            this.brand = brand;
            this.year = year;
        }

    public void start() {
        System.out.println(\"Vehicle starting...\");
    }
    
    public class Car extends Vehicle {
        private int doors;
    }
                        
    public Car(String brand, int year, int doors) {
        super(brand, year);
        this.doors = doors;
    }
    
    @Override
    public void start() {
        System.out.println(\"Car engine starting...\");
    }
    
    public void honk() {
        System.out.println(\"Beep beep!\");
    }
}

A: "What does" super(brand, year) "do in the Car constructor?",
B: "If you create:"" Car myCar = new Car("Toyota", 2020, 4); "and call" myCar.start()", what will be printed?",
C: "Can a Car object access the 'brand' field directly? Why or why not?",
D: "What's the difference between the" start() "method in" Vehicle "and" Car?"

public class Animal {

    public void makeSound() {
        System.out.println(\"Some generic animal sound\");
    }
}

public class Dog extends Animal {
    
    @Override
    public void makeSound() {
        System.out.println(\"Woof!\");
    }
}
    
public class Cat extends Animal {

    @Override
    public void makeSound() {
        System.out.println(\"Meow!\");
    }
}

Animal[] animals = {new Dog(), new Cat(), new Animal()};

for (Animal animal : animals) {
    animal.makeSound();
}

A: "What will be printed when the loop executes?"
B: "How does Java determine which" makeSound() "method to call for each animal?"
C: "What is this type of polymorphism called?"
D: "Could you assign:" Animal myPet = new Dog();"? Why or why not?"

public interface Drawable {
    void draw();
    double getArea();
}
    
    public interface Colorable {
    void setColor(String color);
    String getColor();
}

public class Circle implements Drawable, Colorable {
    private double radius;
    private String color;
}

public Circle(double radius) {
        this.radius = radius;
        this.color = \"black\";
        
    @Override
    public void draw() {
        System.out.println(\"Drawing a circle with radius \" + radius);
    }
    
    @Override
    public double getArea() {
        return Math.PI * radius * radius;
    }
    
    @Override
    public void setColor(String color) {
        this.color = color;
    }

    @Override
    public String getColor() {
        return color;
    }
}

A: "What must any class that implements" Drawable "provide?"
B: "Why can" Circle "implement both Drawable and" Colorable "interfaces?"
C: "What would happen if" Circle "didn't implement the" getArea() "method?"
D: "Can you create: Drawable shape = new Circle(5.0); ?"

public abstract class Shape {
    protected String name;
    
    public Shape(String name) {  
        this.name = name;    
    }
        
    // Abstract method - must be implemented by subclasses
    public abstract double getArea();
    
    // Concrete method - inherited by all subclasses
    public void printInfo() {
        System.out.println(\"Shape: \" + name + \", Area: \" + getArea());    
    }
}
    
public class Rectangle extends Shape {
    private double width, height;
        
    public Rectangle(double width, double height) {
        super(\"Rectangle\");
            this.width = width;
            this.height = height;
        }
        
    @Override
    public double getArea() {
        return width * height;
    }
}

A: "Can you create an object like:" Shape s = new Shape("test");"" ?"
B: "What must the" Rectangle "class provide since it" extends Shape"?"
C: "Does" Rectangle "inherit the" printInfo() "method?"
D: "What's the main difference between an abstract class and an interface?"

public class Student {
    private String name;
    private int id;
    
    public Student(String name, int id) {
        this.name = name;
        this.id = id;
    }
    
    public String getName() { 
        return name;
    }
    
    public int getId() { 
        return id; 
    }
    
    public class Course {
        private String courseName;
        private List enrolledStudents;
    }
            
    public Course(String courseName) {
        this.courseName = courseName;
        this.enrolledStudents = new ArrayList<>();
    }    
            
    public void enrollStudent(Student student) {
        enrolledStudents.add(student);
    }
        
    public void removeStudent(Student student) {
        enrolledStudents.remove(student);
    }
    
    public int getEnrollmentCount() {
        return enrolledStudents.size();
    }
}

A: "What type of relationship exists between" Course "and" Student"?"
B: "If a Course object is destroyed, what happens to the Student objects?"
C: "Can a Student be enrolled in multiple courses?"
D: "What does the" enrollStudent() "method demonstrate about aggregation?"

public class Author {
    private String name;
    private List booksWritten
        
    public Author(String name) {
        this.name = name;
        this.booksWritten = new ArrayList<>();
    }
    
    public void addBook(Book book) {
        booksWritten.add(book);
        book.setAuthor(this);
    } 
    
    public String getName() { 
        return name; 
    }
}

public class Book {
    private String title;
    private Author author;
    
    public Book(String title) {
        this.title = title;
    }
    
    public void setAuthor(Author author) {
        this.author = author;
    }
    
    public Author getAuthor() {
        return author;
    }
        
    public String getTitle() { 
        return title; 
    }
}

// Usage:
    Author author = new Author("J.K. Rowling");
    Book book = new Book("Harry Potter");
    author.addBook(book);

A: "What type of association exists between" Author "and" Book?"
B: "How many authors can a book have in this design?"
C: "What happens when" author.addBook(book) "is called?"
D: "Is this association unidirectional or bidirectional?""

public class BankingService {
    public static class InsufficientFundsException extends Exception {
        public InsufficientFundsException(String message) {
            super(message);
        }
    }
    
    public void transferMoney(BankAccount from, BankAccount to, double amount) throws InsufficientFundsException {
        try {
            if (from.getBalance() < amount) {
                throw new InsufficientFundsException(
                    "Insufficient funds. Available: " + from.getBalance());
            }
            from.withdraw(amount);
            to.deposit(amount);
            System.out.println("Transfer successful");
        } catch (IllegalArgumentException e) {
            System.err.println("Invalid transfer amount: " + e.getMessage());
            throw e;
        } finally {
            System.out.println("Transfer operation completed");
        }
    }    
    
    public static void main(String[] args) {
        BankAccount acc1 = new BankAccount("123", 100.0);
        BankAccount acc2 = new BankAccount("456", 50.0);
        BankingService service = new BankingService();
        
        try {
            service.transferMoney(acc1, acc2, 150.0);
        } catch (InsufficientFundsException e) {
            System.err.println("Transfer failed: " + e.getMessage());
        }
    }
}

A: "What type of exception is" InsufficientFundsException "and why does the transferMoney method need" throws "in its signature?"
B: "What will be printed when the main method tries to transfer $150 from an account with $100?"
C: "When does the" finally "block execute?"
D: "What's the difference between throwing an" InsufficientFundsException "and an" IllegalArgumentException "in this code?"
                                

public class DataContainer {
    private List items;
    
    public DataContainer() {
        this.items = new ArrayList();
            }
            
    public void addItem(T item) {
        items.add(item);
    }
    
    public T getItem(int index) {
        if (index >= 0 && index < items.size()) {
            return items.get(index);
        }
        return null;
    }
    
    public > U findMax(List list) {
        if (list.isEmpty()) 
            return null;

        U max = list.get(0);

        for (U item : list) {
            if (item.compareTo(max) > 0) {
                max = item;
            }
        }

        return max;
    }
    
    public int getSize() {
        return items.size();
    }
}

// Usage:
    DataContainer stringContainer = new DataContainer<>();
    stringContainer.addItem("Hello");
    String result = stringContainer.getItem(0); 

    DataContainer intContainer = new DataContainer<>();
    intContainer.addItem(42);

A: "What does the"  "in the class declaration mean and what advantage does it provide?"
B: "Why doesn't" stringContainer.getItem(0) "require casting to String?"
C: "What does"  "mean in the findMax method signature?"
D: "What would happen if you tried:" stringContainer.addItem(123)"?"