46:"/_next/static/chunks/33yus346z0l_n.js" 47:"/_next/static/chunks/1r8ezocsukqp8.js" 48:"/_next/static/chunks/0iv56yrji_20j.js" 49:"/_next/static/chunks/0wa9m1-tphf9u.js" 4a:"/_next/static/chunks/08cuqqn_f60pp.js" 4b:"/_next/static/chunks/3zdsl3f9b0--r.js" 4c:"/_next/static/chunks/2j22cxchii_xx.js" 4d:"/_next/static/chunks/3bgoyiso1rhn7.js" 4e:"/_next/static/chunks/01a-3hvnqu8wl.js" 4f:"/_next/static/chunks/3m1xjj5kw5fie.js" 50:"/_next/static/chunks/0om3fkgfnicab.js" 51:"/_next/static/chunks/0gafyzg9j9yqj.js" 52:"/_next/static/chunks/20w4eaqlekefm.js" 53:"/_next/static/chunks/449--h5z1s6nq.js" 54:"/_next/static/chunks/3k2gyg36fnag_.js" 55:"/_next/static/chunks/18ggtgz2yf759.js" 56:"/_next/static/chunks/0hlb44ca7-4a2.js" 57:"/_next/static/chunks/253gnmj0-cj17.js" 58:"/_next/static/chunks/09nq57stwzkgf.js" 59:"/_next/static/chunks/082jo-0ajazgr.js" 5a:"/_next/static/chunks/2ozcrjb_hh74t.js" 5b:"/_next/static/chunks/05i8en-x14ibi.js" 5c:"/_next/static/chunks/32izpn90gvm22.js" 5d:"/_next/static/chunks/0jbzid2v9xv3h.js" 5e:"/_next/static/chunks/0i3-eynrkvqi7.js" 5f:"/_next/static/chunks/1tn-0fivsxsv1.js" 60:"/_next/static/chunks/34h36hyf_ggow.js" 61:"/_next/static/chunks/20329i6m_04t6.js" 62:"/_next/static/chunks/161uxd62cjny2.js" 63:"/_next/static/chunks/2k8pepwc4pxns.js" 64:I[593304,["$2b","$2c","$2d","$2e","$2f","$30","$46","$47","$48","$49","$4a","$4b","$4c","$4d","$4e","$4f","$50","$51","$52","$53","$54","$55","$56","$57","$58","$59","$5a","$5b","$5c","$5d","$5e","$5f","$60","$61","$62","$63"],"OwnedHydration"] 65:T7f5,#include #include class Vector2D { private: double x, y; public: Vector2D(double x = 0, double y = 0) : x(x), y(y) {} // Getter methods double getX() const { return x; } double getY() const { return y; } // Operator+ : Vector addition Vector2D operator+(const Vector2D& other) const { return Vector2D(x + other.x, y + other.y); } // Operator- : Vector subtraction Vector2D operator-(const Vector2D& other) const { return Vector2D(x - other.x, y - other.y); } // Operator* : Scalar multiplication Vector2D operator*(double scalar) const { return Vector2D(x * scalar, y * scalar); } // Operator== : Equality comparison bool operator==(const Vector2D& other) const { const double epsilon = 1e-9; return std::abs(x - other.x) < epsilon && std::abs(y - other.y) < epsilon; } // Operator[] : Component access (0 = x, 1 = y) double operator[](int index) const { if (index == 0) return x; if (index == 1) return y; throw std::out_of_range("Index must be 0 or 1"); } // Friend function for commutative scalar multiplication friend Vector2D operator*(double scalar, const Vector2D& v) { return v * scalar; } // Friend function for stream output friend std::ostream& operator<<(std::ostream& os, const Vector2D& v) { os << "(" << v.x << ", " << v.y << ")"; return os; } }; int main() { Vector2D a(3, 4); Vector2D b(1, 2); Vector2D c = a + b; // Vector addition: (4, 6) Vector2D d = a - b; // Vector subtraction: (2, 2) Vector2D e = a * 2.0; // Scalar multiplication: (6, 8) Vector2D f = 2.0 * a; // Commutative: (6, 8) bool equal = (a == b); // Equality check: false double xComp = a[0]; // Index access: 3 std::cout << "c = " << c << std::endl; // Output: c = (4, 6) return 0; }66:T7ec,import math class Vector2D: def __init__(self, x: float = 0, y: float = 0): self._x = x self._y = y @property def x(self) -> float: return self._x @property def y(self) -> float: return self._y # __add__ : Vector addition (a + b) def __add__(self, other: 'Vector2D') -> 'Vector2D': return Vector2D(self._x + other._x, self._y + other._y) # __sub__ : Vector subtraction (a - b) def __sub__(self, other: 'Vector2D') -> 'Vector2D': return Vector2D(self._x - other._x, self._y - other._y) # __mul__ : Scalar multiplication (v * scalar) def __mul__(self, scalar: float) -> 'Vector2D': return Vector2D(self._x * scalar, self._y * scalar) # __rmul__ : Reverse multiplication (scalar * v) def __rmul__(self, scalar: float) -> 'Vector2D': return self.__mul__(scalar) # __eq__ : Equality comparison def __eq__(self, other: object) -> bool: if not isinstance(other, Vector2D): return NotImplemented epsilon = 1e-9 return (abs(self._x - other._x) < epsilon and abs(self._y - other._y) < epsilon) # __getitem__ : Index access (v[0], v[1]) def __getitem__(self, index: int) -> float: if index == 0: return self._x elif index == 1: return self._y raise IndexError("Index must be 0 or 1") # __repr__ : String representation def __repr__(self) -> str: return f"Vector2D({self._x}, {self._y})" # __str__ : Human-readable string def __str__(self) -> str: return f"({self._x}, {self._y})" # Usage a = Vector2D(3, 4) b = Vector2D(1, 2) c = a + b # Vector addition: (4, 6) d = a - b # Vector subtraction: (2, 2) e = a * 2.0 # Scalar multiplication: (6, 8) f = 2.0 * a # Commutative: (6, 8) equal = (a == b) # Equality check: False x_comp = a[0] # Index access: 3 print(f"c = {c}") # Output: c = (4, 6)67:T661,// Generic class: A type-safe container public class Box { private T content; public Box(T content) { this.content = content; } public T getContent() { return content; } public void setContent(T content) { this.content = content; } } // Generic method: Works with any comparable type public class Algorithms { public static > T findMax(T a, T b) { return a.compareTo(b) >= 0 ? a : b; } // Multiple type parameters public static void printPair(K key, V value) { System.out.println(key + " -> " + value); } // Bounded wildcards for flexibility public static double sumOfNumbers(List numbers) { double sum = 0; for (Number n : numbers) { sum += n.doubleValue(); } return sum; } } // Usage - compiler enforces type safety Box stringBox = new Box<>("Hello"); String s = stringBox.getContent(); // No cast needed, type-safe Box intBox = new Box<>(42); Integer i = intBox.getContent(); // Type-safe // Compile-time type checking prevents errors // stringBox.setContent(42); // Compile error! Expected String String maxStr = Algorithms.findMax("apple", "banana"); // "banana" Integer maxInt = Algorithms.findMax(10, 20); // 20 List ints = Arrays.asList(1, 2, 3); List doubles = Arrays.asList(1.5, 2.5, 3.5); double sumInts = Algorithms.sumOfNumbers(ints); // Works with Integer double sumDoubles = Algorithms.sumOfNumbers(doubles); // Works with Double68:T78f,#include #include #include // Class template: Type-safe container template class Box { private: T content; public: Box(T content) : content(content) {} T getContent() const { return content; } void setContent(T newContent) { content = newContent; } }; // Function template: Works with any type supporting operator< template T findMax(T a, T b) { return (a < b) ? b : a; } // Template with multiple type parameters template void printPair(const K& key, const V& value) { std::cout << key << " -> " << value << std::endl; } // Template specialization: Custom behavior for specific types template <> class Box { private: bool content; public: Box(bool content) : content(content) {} bool getContent() const { return content; } // Additional method only for bool specialization bool toggle() { content = !content; return content; } }; // SFINAE: Substitution Failure Is Not An Error // Enable function only for numeric types template typename std::enable_if::value, T>::type square(T value) { return value * value; } int main() { // Template instantiation at compile time Box stringBox("Hello"); std::string s = stringBox.getContent(); // Type-safe Box intBox(42); int i = intBox.getContent(); // Type-safe // Bool specialization has extra method Box boolBox(true); boolBox.toggle(); // Available only for Box // Function template instantiation std::string maxStr = findMax("apple", "banana"); int maxInt = findMax(10, 20); // Type deduction // SFINAE in action int squared = square(5); // Works: 25 // std::string sqStr = square("hi"); // Compile error: not arithmetic return 0; }69:T496,**How templates/generics achieve static polymorphism:** The key insight is that generics allow you to write a single piece of code that behaves differently for different types—without runtime dispatch. When you use `Box` and `Box`, the compiler (or JIT) produces type-specific code: **C++ Templates (Full Monomorphization):** - For each distinct type instantiation, the compiler generates a completely separate copy of the code with concrete types substituted. - `Box` and `Box` become two distinct classes in the compiled binary. - Maximum performance (no indirection), but potential code bloat. **Java Generics (Type Erasure):** - Generics are a compile-time construct. At runtime, `Box` and `Box` are both just `Box

Dynamic (Runtime) Polymorphism