Object-Oriented Programming · Full Mock 1

1
2
3
4
5
6
7
8

class Player:
    def __init__(self, score):
        self.score = score

p = Player(3)
q = p
q.score = 7
print(p.score, p is q)

1
2
3
4
5
6
7

class Config:
    retries = 3

a, b = Config(), Config()
a.retries = 5
Config.retries = 4
print(a.retries, b.retries, Config.retries)

1
2
3
4
5
6
7
8
9
10
11

from dataclasses import dataclass, field

@dataclass(frozen=True)
class Item:
    name: str
    price: float = 0.0
    tags: tuple = field(default_factory=tuple)

a = Item("pen", 1.5)
b = Item("pen", 1.5)
print(a, a == b, len({a, b}))

1
2
3
4
5
6
7
8
9
10
11

public class Main {
    static class Coin {
        private final int paise;
        Coin(int p) { paise = p; }
        boolean sameValue(Coin other) { return paise == other.paise; }
    }

    public static void main(String[] args) {
        System.out.println(new Coin(50).sameValue(new Coin(50)));
    }
}

1
2
3
4
5
6
7
8
9
10
11

class Employee:
    def __init__(self, name):
        self.name = name

class Manager(Employee):
    def __init__(self, name, team):
        super().__init__(name)
        self.team = team

m = Manager("Asha", 5)
print(m.name, m.team, isinstance(m, Employee))

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

#include <iostream>

struct Shape {
    virtual const char* name() const { return "shape"; }
    virtual ~Shape() = default;
};
struct Circle : Shape {
    const char* name() const override { return "circle"; }
};

void byValue(Shape s)      { std::cout << s.name() << ' '; }
void byRef(const Shape& s) { std::cout << s.name() << ' '; }

int main() {
    Circle c;
    byValue(c);
    byRef(c);
    std::cout << '\n';
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

#include <iostream>
#include <string>

struct Widget {
    Widget(int w) { std::cout << "Widget(" << w << ") "; }
    Widget(std::string s) { std::cout << "Widget(" << s << ") "; }
};

struct Button : Widget {
    using Widget::Widget;
};

int main() {
    Button a(7);
    Button b(std::string("ok"));
    std::cout << '\n';
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

class Duck:
    def speak(self):
        return "Quack"

class Robot:
    def speak(self):
        return "Beep"

class Stone:
    pass

def talk(x):
    return x.speak() if hasattr(x, "speak") else "(silence)"

print(*(talk(t) for t in (Duck(), Robot(), Stone())))

1
2
3
4
5
6
7
8
9
10
11
12
13

struct Shape {
    virtual double area() const { return 0; }
    virtual ~Shape() = default;
};

struct Circle : Shape {
    double r = 1;
    double area() override { return 3.14159 * r * r; }
};

int main() {
    Circle c;
}

1
2
3
4
5
6
7
8
9
10
11
12

#include <compare>
#include <iostream>

struct Date {
    int y, m, d;
    auto operator<=>(const Date&) const = default;
};

int main() {
    Date a{2026, 3, 1}, b{2025, 12, 31}, c{2026, 3, 1};
    std::cout << std::boolalpha << (a > b) << ' ' << (a == c) << ' ' << (b >= a) << '\n';
}

1
2
3
4
5
6
7
8
9
10
11

#include <iostream>

struct Sensor {
    virtual double read() const = 0;
    virtual ~Sensor() = default;
};

int main() {
    Sensor s;
    std::cout << s.read() << '\n';
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

import java.util.*;

public class Main {
    interface Payable { double amount(); }
    interface Taxable { default double tax() { return 0.18; } }

    record Invoice(double amount) implements Payable, Taxable { }
    record Refund(double amount) implements Payable { }

    public static void main(String[] args) {
        List<Payable> items = List.of(new Invoice(100), new Refund(-40), new Invoice(50));
        double total = 0;
        for (Payable p : items) {
            double t = (p instanceof Taxable tx) ? tx.tax() : 0;
            total += p.amount() * (1 + t);
        }
        System.out.printf("%.1f%n", total);
    }
}

1
2
3
4
5
6
7
8
9
10
11

import copy

class Team:
    def __init__(self, name, members):
        self.name, self.members = name, members

t1 = Team("A", ["asha"])
t2 = copy.copy(t1)
t2.name = "B"
t2.members.append("ravi")
print(t1.name, t1.members)

1
2
3
4
5
6
7
8
9
10

import copy

class Node:
    pass

a = Node()
a.me = a
a.tags = ["x"]
b = copy.deepcopy(a)
print(b.me is b, b is a, b.tags is a.tags)

1
2
3
4
5
6
7

public class Main {
    public static void main(String[] args) {
        final int maxUsers = 50;
        maxUsers = 60;
        System.out.println(maxUsers);
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

#include <iostream>

struct Box {
    int value = 1;
    int& get()             { std::cout << "non-const "; return value; }
    const int& get() const { std::cout << "const "; return value; }
};

int main() {
    Box b;
    const Box cb;
    const Box& ref = b;
    b.get();
    cb.get();
    ref.get();
    std::cout << '\n';
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

public class Main {
    static class InsufficientFundsException extends Exception {
        final double shortBy;
        InsufficientFundsException(double shortBy) {
            super("short by " + shortBy);
            this.shortBy = shortBy;
        }
    }

    static void withdraw(double balance, double amount) throws InsufficientFundsException {
        if (amount > balance) throw new InsufficientFundsException(amount - balance);
        System.out.print("ok ");
    }

    public static void main(String[] args) {
        try {
            withdraw(100, 50);
            withdraw(100, 130);
        } catch (InsufficientFundsException e) {
            System.out.println(e.getMessage() + " / " + e.shortBy);
        }
    }
}

1
2
3
4
5
6
7
8
9
10
11
12

#include <iostream>

struct Base { virtual const char* name() const { return "base"; } virtual ~Base() = default; };
struct Derived : Base { const char* name() const override { return "derived"; } };

void copyRethrow()  { try { throw Derived(); } catch (const Base& e) { throw e; } }
void plainRethrow() { try { throw Derived(); } catch (const Base& e) { throw; } }

int main() {
    try { copyRethrow(); }  catch (const Base& e) { std::cout << e.name() << ' '; }
    try { plainRethrow(); } catch (const Base& e) { std::cout << e.name() << '\n'; }
}

1
2
3
4
5
6
7
8
9
10
11
12
13

log = []

def handler():
    try:
        [].pop()
    except IndexError as e:
        log.append(f"logged {type(e).__name__}")
        raise

try:
    handler()
except Exception as e:
    print(log, type(e).__name__, str(e))

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

import java.util.*;

public class Main {
    static final class Stack<T> {
        private final Deque<T> items = new ArrayDeque<>();
        void push(T x) { items.push(x); }
        T pop()        { return items.pop(); }
        int size()     { return items.size(); }
    }

    public static void main(String[] args) {
        Stack<Integer> s = new Stack<>();
        for (int i = 1; i <= 3; i++) s.push(i * 10);
        int top = s.pop();
        System.out.println(top + " " + s.size());
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

class Circle:
    def area(self):
        return 3

class Square:
    def area(self):
        return 4

def make_shape(kind):
    registry = {"circle": Circle, "square": Square}
    if kind not in registry:
        raise ValueError(kind)
    return registry[kind]()

shapes = [make_shape(k) for k in ("square", "circle", "square")]
print(sum(s.area() for s in shapes), type(shapes[1]).__name__)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

public class Main {
    static abstract class Approver {
        private Approver next;
        Approver then(Approver n) { next = n; return n; }
        String handle(int amount) {
            if (canApprove(amount)) return name();
            return next == null ? "rejected" : next.handle(amount);
        }
        abstract boolean canApprove(int amount);
        abstract String name();
    }
    static class Lead extends Approver { boolean canApprove(int a) { return a <= 1000; } String name() { return "lead"; } }
    static class Manager extends Approver { boolean canApprove(int a) { return a <= 10000; } String name() { return "manager"; } }
    static class Director extends Approver { boolean canApprove(int a) { return a <= 50000; } String name() { return "director"; } }

    public static void main(String[] args) {
        Approver chain = new Lead();
        chain.then(new Manager()).then(new Director());
        System.out.println(chain.handle(500) + " " + chain.handle(7000) + " " + chain.handle(90000));
    }
}