OOP for DSA & Design Rounds

1class Wallet {                        // a UPI-style wallet2    private final String owner;              // final: set once, in the constructor3    private long balancePaise;               // private: only the methods below can change it4 5    Wallet(String owner) {6        this(owner, 0);                      // reuse the other constructor7    }8 9    Wallet(String owner, long openingPaise) {10        if (openingPaise < 0) throw new IllegalArgumentException("negative opening balance");11        this.owner = owner;                  // this.owner is the field, owner is the parameter12        this.balancePaise = openingPaise;13    }14 15    boolean pay(long paise) {                // every change goes through one checked door16        if (paise <= 0 || paise > balancePaise) return false;17        balancePaise -= paise;18        return true;19    }20 21    long balance() {22        return balancePaise;23    }24 25    String owner() {26        return owner;27    }28}

1class ParkingLot {2    static int opened = 0;                   // ONE copy, stored with the class3    private final int[] free;                // one copy PER OBJECT: free[1] big, free[2] medium, free[3] small4 5    ParkingLot(int big, int medium, int small) {6        free = new int[] {0, big, medium, small};7        opened++;                                    // bumps the shared count8    }9 10    boolean addCar(int carType) {11        if (free[carType] == 0) return false;12        free[carType]--;                             // changes only THIS lot13        return true;14    }15}

1class LinkedStack {2    private static class Node {              // static nested: no hidden link to a LinkedStack3        final int val;4        final Node next;5 6        Node(int val, Node next) {7            this.val = val;8            this.next = next;9        }10    }11 12    private Node top;                        // null means empty13    private int size;14 15    void push(int x) {16        top = new Node(x, top);              // the new node points at the old top17        size++;18    }19 20    int pop() {21        int val = top.val;22        top = top.next;                      // the old top becomes garbage23        size--;24        return val;25    }26 27    int peek() {28        return top.val;29    }30 31    boolean isEmpty() {32        return top == null;33    }34 35    int size() {36        return size;37    }38}

1class Countdown implements Iterable<Integer> {2    private final int start;3 4    Countdown(int start) {5        this.start = start;6    }7 8    public Iterator<Integer> iterator() {9        return new Ticker();                 // each Ticker is tied to THIS Countdown10    }11 12    private class Ticker implements Iterator<Integer> {   // inner (no static): sees the outer object13        private int next = start;            // reads the outer object's field directly14 15        public boolean hasNext() {16            return next >= 0;17        }18 19        public Integer next() {20            return next--;21        }22    }23}

1// LeetCode already defines these above your Solution: use them, don't declare them again.2class ListNode {3    int val;                                 // package-private fields: read them directly4    ListNode next;5 6    ListNode() {}7 8    ListNode(int val) {9        this.val = val;10    }11 12    ListNode(int val, ListNode next) {13        this.val = val;14        this.next = next;15    }16}17 18class TreeNode {19    int val;20    TreeNode left;21    TreeNode right;22 23    TreeNode() {}24 25    TreeNode(int val) {26        this.val = val;27    }28 29    TreeNode(int val, TreeNode left, TreeNode right) {30        this.val = val;31        this.left = left;32        this.right = right;33    }34}

1interface IntStack {                         // WHAT a stack can do: no fields, no code2    void push(int x);3 4    int pop();5 6    boolean isEmpty();7}8 9class ArrayIntStack implements IntStack {     // HOW, version 1: a growing int[]10    private int[] items = new int[8];11    private int size;12 13    public void push(int x) {14        if (size == items.length) items = Arrays.copyOf(items, size * 2);15        items[size++] = x;16    }17 18    public int pop() {19        return items[--size];20    }21 22    public boolean isEmpty() {23        return size == 0;24    }25}26 27class DequeIntStack implements IntStack {     // HOW, version 2: wrap an ArrayDeque28    private final Deque<Integer> deque = new ArrayDeque<>();29 30    public void push(int x) {31        deque.push(x);32    }33 34    public int pop() {35        return deque.pop();36    }37 38    public boolean isEmpty() {39        return deque.isEmpty();40    }41}42 43static int[] reversed(int[] values, IntStack stack) {   // works with ANY IntStack44    for (int v : values) stack.push(v);45    int[] out = new int[values.length];46    for (int i = 0; i < out.length; i++) out[i] = stack.pop();47    return out;48}

1class Cell {                          // a grid position used as a HashSet key2    final int r;3    final int c;4 5    Cell(int r, int c) {6        this.r = r;7        this.c = c;8    }9 10    @Override11    public boolean equals(Object o) {12        if (this == o) return true;                  // same object13        if (!(o instanceof Cell other)) return false; // null or a different type14        return r == other.r && c == other.c;         // same fields: equal15    }16 17    @Override18    public int hashCode() {19        return 31 * r + c;                           // equal cells get equal hash codes20    }21}22 23class BrokenCell {                    // equals WITHOUT hashCode24    final int r;25    final int c;26 27    BrokenCell(int r, int c) {28        this.r = r;29        this.c = c;30    }31 32    @Override33    public boolean equals(Object o) {34        return o instanceof BrokenCell other && r == other.r && c == other.c;35    }36    // no hashCode(): equal cells usually land in different buckets, so HashSet never compares them37}

1record Point(int r, int c) {}                // fields, constructor, r(), c(), equals, hashCode, toString2 3record Edge(int to, int weight) {4    Edge {                                   // compact constructor: validate, fields are set after it5        if (weight < 0) throw new IllegalArgumentException("negative weight");6    }7 8    Edge heavier(int extra) {                // records are immutable: "change" means a new record9        return new Edge(to, weight + extra);10    }11}12 13static int distinctCells(int[][] moves) {    // Point as a HashSet key: no equals/hashCode to write14    Set<Point> seen = new HashSet<>();15    int r = 0, c = 0;16    seen.add(new Point(r, c));17    for (int[] m : moves) {18        r += m[0];19        c += m[1];20        seen.add(new Point(r, c));21    }22    return seen.size();23}

1static <T extends Comparable<T>> T max(List<T> items) {   // any T that can compare itself to a T2    T best = items.get(0);3    for (T item : items) {4        if (item.compareTo(best) > 0) best = item;5    }6    return best;7}8 9class Pair<A, B> {                    // a tiny generic class (a record works too)10    final A first;11    final B second;12 13    Pair(A first, B second) {14        this.first = first;15        this.second = second;16    }17}

1enum Direction {2    UP(-1, 0), RIGHT(0, 1), DOWN(1, 0), LEFT(0, -1);   // the only four Direction objects that will ever exist3 4    private static final Direction[] ALL = values();    // values() copies the array on every call: cache it5 6    final int dr;                                       // each constant carries its own data7    final int dc;8 9    Direction(int dr, int dc) {10        this.dr = dr;11        this.dc = dc;12    }13 14    Direction turnRight() {15        return ALL[(ordinal() + 1) % 4];                // clockwise order: UP, RIGHT, DOWN, LEFT16    }17 18    Direction turnLeft() {19        return ALL[(ordinal() + 3) % 4];20    }21}22 23static int[] walk(String commands) {                    // F = forward, R = turn right, L = turn left24    Direction d = Direction.UP;25    int r = 0, c = 0;26    for (char ch : commands.toCharArray()) {27        switch (ch) {28            case 'F' -> {29                r += d.dr;30                c += d.dc;31            }32            case 'R' -> d = d.turnRight();33            case 'L' -> d = d.turnLeft();34            default -> throw new IllegalArgumentException("unknown command " + ch);35        }36    }37    return new int[] {r, c};38}