diff --git a/solution/0800-0899/0855.Exam Room/README.md b/solution/0800-0899/0855.Exam Room/README.md
index b7bf963d84345..26edf8cd9d218 100644
--- a/solution/0800-0899/0855.Exam Room/README.md	
+++ b/solution/0800-0899/0855.Exam Room/README.md	
@@ -58,9 +58,9 @@ seat() -> 5，学生最后坐在 5 号座位上。
 
 ### 方法一：有序集合 + 哈希表
 
-考虑到每次 $seat()$ 时都需要找到最大距离的座位，我们可以使用有序集合来保存座位区间。有序集合的每个元素为一个二元组 $(l, r)$，表示 $l$ 和 $r$ 之间（不包括 $l$ 和 $r$）的座位可以坐学生。初始时有序集合中只有一个元素 $(-1, n)$，表示 $(-1, n)$ 之间的座位可以坐学生。
+考虑到每次 $\text{seat}()$ 时都需要找到最大距离的座位，我们可以使用有序集合来保存座位区间。有序集合的每个元素为一个二元组 $(l, r)$，表示 $l$ 和 $r$ 之间（不包括 $l$ 和 $r$）的座位可以坐学生。初始时有序集合中只有一个元素 $(-1, n)$，表示 $(-1, n)$ 之间的座位可以坐学生。
 
-另外，我们使用两个哈希表 `left` 和 `right` 来维护每个有学生的座位的左右邻居学生，方便我们在 $leave(p)$ 时合并两个座位区间。
+另外，我们使用两个哈希表 $\textit{left}$ 和 $\textit{right}$ 来维护每个有学生的座位的左右邻居学生，方便我们在 $\text{leave}(p)$ 时合并两个座位区间。
 
 时间复杂度 $O(\log n)$，空间复杂度 $O(n)$。其中 $n$ 为考场的座位数。
 
@@ -329,6 +329,562 @@ func (this *ExamRoom) del(s []int) {
  */
 ```
 
+#### TypeScript
+
+```ts
+class ExamRoom {
+    private ts: TreeSet<number[]> = new TreeSet<number[]>((a, b) => {
+        const d1 = this.dist(a),
+            d2 = this.dist(b);
+        return d1 === d2 ? a[0] - b[0] : d2 - d1;
+    });
+    private left: Map<number, number> = new Map();
+    private right: Map<number, number> = new Map();
+    private n: number;
+
+    constructor(n: number) {
+        this.n = n;
+        this.add([-1, n]);
+    }
+
+    seat(): number {
+        const s = this.ts.first();
+        let p = Math.floor((s[0] + s[1]) / 2);
+        if (s[0] === -1) {
+            p = 0;
+        } else if (s[1] === this.n) {
+            p = this.n - 1;
+        }
+        this.del(s);
+        this.add([s[0], p]);
+        this.add([p, s[1]]);
+        return p;
+    }
+
+    leave(p: number): void {
+        const l = this.left.get(p)!;
+        const r = this.right.get(p)!;
+        this.del([l, p]);
+        this.del([p, r]);
+        this.add([l, r]);
+    }
+
+    private dist(s: number[]): number {
+        const [l, r] = s;
+        return l === -1 || r === this.n ? r - l - 1 : Math.floor((r - l) / 2);
+    }
+
+    private add(s: number[]): void {
+        this.ts.add(s);
+        this.left.set(s[1], s[0]);
+        this.right.set(s[0], s[1]);
+    }
+
+    private del(s: number[]): void {
+        this.ts.delete(s);
+        this.left.delete(s[1]);
+        this.right.delete(s[0]);
+    }
+}
+
+type Compare<T> = (lhs: T, rhs: T) => number;
+
+class RBTreeNode<T = number> {
+    data: T;
+    count: number;
+    left: RBTreeNode<T> | null;
+    right: RBTreeNode<T> | null;
+    parent: RBTreeNode<T> | null;
+    color: number;
+    constructor(data: T) {
+        this.data = data;
+        this.left = this.right = this.parent = null;
+        this.color = 0;
+        this.count = 1;
+    }
+
+    sibling(): RBTreeNode<T> | null {
+        if (!this.parent) return null; // sibling null if no parent
+        return this.isOnLeft() ? this.parent.right : this.parent.left;
+    }
+
+    isOnLeft(): boolean {
+        return this === this.parent!.left;
+    }
+
+    hasRedChild(): boolean {
+        return (
+            Boolean(this.left && this.left.color === 0) ||
+            Boolean(this.right && this.right.color === 0)
+        );
+    }
+}
+
+class RBTree<T> {
+    root: RBTreeNode<T> | null;
+    lt: (l: T, r: T) => boolean;
+    constructor(compare: Compare<T> = (l: T, r: T) => (l < r ? -1 : l > r ? 1 : 0)) {
+        this.root = null;
+        this.lt = (l: T, r: T) => compare(l, r) < 0;
+    }
+
+    rotateLeft(pt: RBTreeNode<T>): void {
+        const right = pt.right!;
+        pt.right = right.left;
+
+        if (pt.right) pt.right.parent = pt;
+        right.parent = pt.parent;
+
+        if (!pt.parent) this.root = right;
+        else if (pt === pt.parent.left) pt.parent.left = right;
+        else pt.parent.right = right;
+
+        right.left = pt;
+        pt.parent = right;
+    }
+
+    rotateRight(pt: RBTreeNode<T>): void {
+        const left = pt.left!;
+        pt.left = left.right;
+
+        if (pt.left) pt.left.parent = pt;
+        left.parent = pt.parent;
+
+        if (!pt.parent) this.root = left;
+        else if (pt === pt.parent.left) pt.parent.left = left;
+        else pt.parent.right = left;
+
+        left.right = pt;
+        pt.parent = left;
+    }
+
+    swapColor(p1: RBTreeNode<T>, p2: RBTreeNode<T>): void {
+        const tmp = p1.color;
+        p1.color = p2.color;
+        p2.color = tmp;
+    }
+
+    swapData(p1: RBTreeNode<T>, p2: RBTreeNode<T>): void {
+        const tmp = p1.data;
+        p1.data = p2.data;
+        p2.data = tmp;
+    }
+
+    fixAfterInsert(pt: RBTreeNode<T>): void {
+        let parent = null;
+        let grandParent = null;
+
+        while (pt !== this.root && pt.color !== 1 && pt.parent?.color === 0) {
+            parent = pt.parent;
+            grandParent = pt.parent.parent;
+
+            /*  Case : A
+                Parent of pt is left child of Grand-parent of pt */
+            if (parent === grandParent?.left) {
+                const uncle = grandParent.right;
+
+                /* Case : 1
+                   The uncle of pt is also red
+                   Only Recoloring required */
+                if (uncle && uncle.color === 0) {
+                    grandParent.color = 0;
+                    parent.color = 1;
+                    uncle.color = 1;
+                    pt = grandParent;
+                } else {
+                    /* Case : 2
+                       pt is right child of its parent
+                       Left-rotation required */
+                    if (pt === parent.right) {
+                        this.rotateLeft(parent);
+                        pt = parent;
+                        parent = pt.parent;
+                    }
+
+                    /* Case : 3
+                       pt is left child of its parent
+                       Right-rotation required */
+                    this.rotateRight(grandParent);
+                    this.swapColor(parent!, grandParent);
+                    pt = parent!;
+                }
+            } else {
+                /* Case : B
+               Parent of pt is right child of Grand-parent of pt */
+                const uncle = grandParent!.left;
+
+                /*  Case : 1
+                    The uncle of pt is also red
+                    Only Recoloring required */
+                if (uncle != null && uncle.color === 0) {
+                    grandParent!.color = 0;
+                    parent.color = 1;
+                    uncle.color = 1;
+                    pt = grandParent!;
+                } else {
+                    /* Case : 2
+                       pt is left child of its parent
+                       Right-rotation required */
+                    if (pt === parent.left) {
+                        this.rotateRight(parent);
+                        pt = parent;
+                        parent = pt.parent;
+                    }
+
+                    /* Case : 3
+                       pt is right child of its parent
+                       Left-rotation required */
+                    this.rotateLeft(grandParent!);
+                    this.swapColor(parent!, grandParent!);
+                    pt = parent!;
+                }
+            }
+        }
+        this.root!.color = 1;
+    }
+
+    delete(val: T): boolean {
+        const node = this.find(val);
+        if (!node) return false;
+        node.count--;
+        if (!node.count) this.deleteNode(node);
+        return true;
+    }
+
+    deleteAll(val: T): boolean {
+        const node = this.find(val);
+        if (!node) return false;
+        this.deleteNode(node);
+        return true;
+    }
+
+    deleteNode(v: RBTreeNode<T>): void {
+        const u = BSTreplace(v);
+
+        // True when u and v are both black
+        const uvBlack = (u === null || u.color === 1) && v.color === 1;
+        const parent = v.parent!;
+
+        if (!u) {
+            // u is null therefore v is leaf
+            if (v === this.root) this.root = null;
+            // v is root, making root null
+            else {
+                if (uvBlack) {
+                    // u and v both black
+                    // v is leaf, fix double black at v
+                    this.fixDoubleBlack(v);
+                } else {
+                    // u or v is red
+                    if (v.sibling()) {
+                        // sibling is not null, make it red"
+                        v.sibling()!.color = 0;
+                    }
+                }
+                // delete v from the tree
+                if (v.isOnLeft()) parent.left = null;
+                else parent.right = null;
+            }
+            return;
+        }
+
+        if (!v.left || !v.right) {
+            // v has 1 child
+            if (v === this.root) {
+                // v is root, assign the value of u to v, and delete u
+                v.data = u.data;
+                v.left = v.right = null;
+            } else {
+                // Detach v from tree and move u up
+                if (v.isOnLeft()) parent.left = u;
+                else parent.right = u;
+                u.parent = parent;
+                if (uvBlack) this.fixDoubleBlack(u);
+                // u and v both black, fix double black at u
+                else u.color = 1; // u or v red, color u black
+            }
+            return;
+        }
+
+        // v has 2 children, swap data with successor and recurse
+        this.swapData(u, v);
+        this.deleteNode(u);
+
+        // find node that replaces a deleted node in BST
+        function BSTreplace(x: RBTreeNode<T>): RBTreeNode<T> | null {
+            // when node have 2 children
+            if (x.left && x.right) return successor(x.right);
+            // when leaf
+            if (!x.left && !x.right) return null;
+            // when single child
+            return x.left ?? x.right;
+        }
+        // find node that do not have a left child
+        // in the subtree of the given node
+        function successor(x: RBTreeNode<T>): RBTreeNode<T> {
+            let temp = x;
+            while (temp.left) temp = temp.left;
+            return temp;
+        }
+    }
+
+    fixDoubleBlack(x: RBTreeNode<T>): void {
+        if (x === this.root) return; // Reached root
+
+        const sibling = x.sibling();
+        const parent = x.parent!;
+        if (!sibling) {
+            // No sibiling, double black pushed up
+            this.fixDoubleBlack(parent);
+        } else {
+            if (sibling.color === 0) {
+                // Sibling red
+                parent.color = 0;
+                sibling.color = 1;
+                if (sibling.isOnLeft()) this.rotateRight(parent);
+                // left case
+                else this.rotateLeft(parent); // right case
+                this.fixDoubleBlack(x);
+            } else {
+                // Sibling black
+                if (sibling.hasRedChild()) {
+                    // at least 1 red children
+                    if (sibling.left && sibling.left.color === 0) {
+                        if (sibling.isOnLeft()) {
+                            // left left
+                            sibling.left.color = sibling.color;
+                            sibling.color = parent.color;
+                            this.rotateRight(parent);
+                        } else {
+                            // right left
+                            sibling.left.color = parent.color;
+                            this.rotateRight(sibling);
+                            this.rotateLeft(parent);
+                        }
+                    } else {
+                        if (sibling.isOnLeft()) {
+                            // left right
+                            sibling.right!.color = parent.color;
+                            this.rotateLeft(sibling);
+                            this.rotateRight(parent);
+                        } else {
+                            // right right
+                            sibling.right!.color = sibling.color;
+                            sibling.color = parent.color;
+                            this.rotateLeft(parent);
+                        }
+                    }
+                    parent.color = 1;
+                } else {
+                    // 2 black children
+                    sibling.color = 0;
+                    if (parent.color === 1) this.fixDoubleBlack(parent);
+                    else parent.color = 1;
+                }
+            }
+        }
+    }
+
+    insert(data: T): boolean {
+        // search for a position to insert
+        let parent = this.root;
+        while (parent) {
+            if (this.lt(data, parent.data)) {
+                if (!parent.left) break;
+                else parent = parent.left;
+            } else if (this.lt(parent.data, data)) {
+                if (!parent.right) break;
+                else parent = parent.right;
+            } else break;
+        }
+
+        // insert node into parent
+        const node = new RBTreeNode(data);
+        if (!parent) this.root = node;
+        else if (this.lt(node.data, parent.data)) parent.left = node;
+        else if (this.lt(parent.data, node.data)) parent.right = node;
+        else {
+            parent.count++;
+            return false;
+        }
+        node.parent = parent;
+        this.fixAfterInsert(node);
+        return true;
+    }
+
+    find(data: T): RBTreeNode<T> | null {
+        let p = this.root;
+        while (p) {
+            if (this.lt(data, p.data)) {
+                p = p.left;
+            } else if (this.lt(p.data, data)) {
+                p = p.right;
+            } else break;
+        }
+        return p ?? null;
+    }
+
+    *inOrder(root: RBTreeNode<T> = this.root!): Generator<T, undefined, void> {
+        if (!root) return;
+        for (const v of this.inOrder(root.left!)) yield v;
+        yield root.data;
+        for (const v of this.inOrder(root.right!)) yield v;
+    }
+
+    *reverseInOrder(root: RBTreeNode<T> = this.root!): Generator<T, undefined, void> {
+        if (!root) return;
+        for (const v of this.reverseInOrder(root.right!)) yield v;
+        yield root.data;
+        for (const v of this.reverseInOrder(root.left!)) yield v;
+    }
+}
+
+class TreeSet<T = number> {
+    _size: number;
+    tree: RBTree<T>;
+    compare: Compare<T>;
+    constructor(
+        collection: T[] | Compare<T> = [],
+        compare: Compare<T> = (l: T, r: T) => (l < r ? -1 : l > r ? 1 : 0),
+    ) {
+        if (typeof collection === 'function') {
+            compare = collection;
+            collection = [];
+        }
+        this._size = 0;
+        this.compare = compare;
+        this.tree = new RBTree(compare);
+        for (const val of collection) this.add(val);
+    }
+
+    size(): number {
+        return this._size;
+    }
+
+    has(val: T): boolean {
+        return !!this.tree.find(val);
+    }
+
+    add(val: T): boolean {
+        const successful = this.tree.insert(val);
+        this._size += successful ? 1 : 0;
+        return successful;
+    }
+
+    delete(val: T): boolean {
+        const deleted = this.tree.deleteAll(val);
+        this._size -= deleted ? 1 : 0;
+        return deleted;
+    }
+
+    ceil(val: T): T | undefined {
+        let p = this.tree.root;
+        let higher = null;
+        while (p) {
+            if (this.compare(p.data, val) >= 0) {
+                higher = p;
+                p = p.left;
+            } else {
+                p = p.right;
+            }
+        }
+        return higher?.data;
+    }
+
+    floor(val: T): T | undefined {
+        let p = this.tree.root;
+        let lower = null;
+        while (p) {
+            if (this.compare(val, p.data) >= 0) {
+                lower = p;
+                p = p.right;
+            } else {
+                p = p.left;
+            }
+        }
+        return lower?.data;
+    }
+
+    higher(val: T): T | undefined {
+        let p = this.tree.root;
+        let higher = null;
+        while (p) {
+            if (this.compare(val, p.data) < 0) {
+                higher = p;
+                p = p.left;
+            } else {
+                p = p.right;
+            }
+        }
+        return higher?.data;
+    }
+
+    lower(val: T): T | undefined {
+        let p = this.tree.root;
+        let lower = null;
+        while (p) {
+            if (this.compare(p.data, val) < 0) {
+                lower = p;
+                p = p.right;
+            } else {
+                p = p.left;
+            }
+        }
+        return lower?.data;
+    }
+
+    first(): T | undefined {
+        return this.tree.inOrder().next().value;
+    }
+
+    last(): T | undefined {
+        return this.tree.reverseInOrder().next().value;
+    }
+
+    shift(): T | undefined {
+        const first = this.first();
+        if (first === undefined) return undefined;
+        this.delete(first);
+        return first;
+    }
+
+    pop(): T | undefined {
+        const last = this.last();
+        if (last === undefined) return undefined;
+        this.delete(last);
+        return last;
+    }
+
+    *[Symbol.iterator](): Generator<T, void, void> {
+        for (const val of this.values()) yield val;
+    }
+
+    *keys(): Generator<T, void, void> {
+        for (const val of this.values()) yield val;
+    }
+
+    *values(): Generator<T, undefined, void> {
+        for (const val of this.tree.inOrder()) yield val;
+        return undefined;
+    }
+
+    /**
+     * Return a generator for reverse order traversing the set
+     */
+    *rvalues(): Generator<T, undefined, void> {
+        for (const val of this.tree.reverseInOrder()) yield val;
+        return undefined;
+    }
+}
+
+/**
+ * Your ExamRoom object will be instantiated and called as such:
+ * var obj = new ExamRoom(n)
+ * var param_1 = obj.seat()
+ * obj.leave(p)
+ */
+```
+
 <!-- tabs:end -->
 
 <!-- solution:end -->
diff --git a/solution/0800-0899/0855.Exam Room/README_EN.md b/solution/0800-0899/0855.Exam Room/README_EN.md
index 832cc86b1d775..63335bebf97c1 100644
--- a/solution/0800-0899/0855.Exam Room/README_EN.md	
+++ b/solution/0800-0899/0855.Exam Room/README_EN.md	
@@ -68,7 +68,13 @@ examRoom.seat(); // return 5, the student sits at the last seat number 5.
 
 <!-- solution:start -->
 
-### Solution 1
+### Solution 1: Ordered Set + Hash Table
+
+Considering that each time we call $\text{seat}()$, we need to find the seat with the maximum distance, we can use an ordered set to store seat intervals. Each element of the ordered set is a tuple $(l, r)$, indicating that the seats between $l$ and $r$ (excluding $l$ and $r$) can be occupied by a student. Initially, the ordered set contains only one element $(-1, n)$, indicating that the seats between $(-1, n)$ can be occupied by a student.
+
+Additionally, we use two hash tables $\textit{left}$ and $\textit{right}$ to maintain the left and right neighbors of each occupied seat, making it easier to merge two seat intervals when calling $\text{leave}(p)$.
+
+The time complexity is $O(\log n)$, and the space complexity is $O(n)$. Here, $n$ is the number of seats in the exam room.
 
 <!-- tabs:start -->
 
@@ -335,6 +341,562 @@ func (this *ExamRoom) del(s []int) {
  */
 ```
 
+#### TypeScript
+
+```ts
+class ExamRoom {
+    private ts: TreeSet<number[]> = new TreeSet<number[]>((a, b) => {
+        const d1 = this.dist(a),
+            d2 = this.dist(b);
+        return d1 === d2 ? a[0] - b[0] : d2 - d1;
+    });
+    private left: Map<number, number> = new Map();
+    private right: Map<number, number> = new Map();
+    private n: number;
+
+    constructor(n: number) {
+        this.n = n;
+        this.add([-1, n]);
+    }
+
+    seat(): number {
+        const s = this.ts.first();
+        let p = Math.floor((s[0] + s[1]) / 2);
+        if (s[0] === -1) {
+            p = 0;
+        } else if (s[1] === this.n) {
+            p = this.n - 1;
+        }
+        this.del(s);
+        this.add([s[0], p]);
+        this.add([p, s[1]]);
+        return p;
+    }
+
+    leave(p: number): void {
+        const l = this.left.get(p)!;
+        const r = this.right.get(p)!;
+        this.del([l, p]);
+        this.del([p, r]);
+        this.add([l, r]);
+    }
+
+    private dist(s: number[]): number {
+        const [l, r] = s;
+        return l === -1 || r === this.n ? r - l - 1 : Math.floor((r - l) / 2);
+    }
+
+    private add(s: number[]): void {
+        this.ts.add(s);
+        this.left.set(s[1], s[0]);
+        this.right.set(s[0], s[1]);
+    }
+
+    private del(s: number[]): void {
+        this.ts.delete(s);
+        this.left.delete(s[1]);
+        this.right.delete(s[0]);
+    }
+}
+
+type Compare<T> = (lhs: T, rhs: T) => number;
+
+class RBTreeNode<T = number> {
+    data: T;
+    count: number;
+    left: RBTreeNode<T> | null;
+    right: RBTreeNode<T> | null;
+    parent: RBTreeNode<T> | null;
+    color: number;
+    constructor(data: T) {
+        this.data = data;
+        this.left = this.right = this.parent = null;
+        this.color = 0;
+        this.count = 1;
+    }
+
+    sibling(): RBTreeNode<T> | null {
+        if (!this.parent) return null; // sibling null if no parent
+        return this.isOnLeft() ? this.parent.right : this.parent.left;
+    }
+
+    isOnLeft(): boolean {
+        return this === this.parent!.left;
+    }
+
+    hasRedChild(): boolean {
+        return (
+            Boolean(this.left && this.left.color === 0) ||
+            Boolean(this.right && this.right.color === 0)
+        );
+    }
+}
+
+class RBTree<T> {
+    root: RBTreeNode<T> | null;
+    lt: (l: T, r: T) => boolean;
+    constructor(compare: Compare<T> = (l: T, r: T) => (l < r ? -1 : l > r ? 1 : 0)) {
+        this.root = null;
+        this.lt = (l: T, r: T) => compare(l, r) < 0;
+    }
+
+    rotateLeft(pt: RBTreeNode<T>): void {
+        const right = pt.right!;
+        pt.right = right.left;
+
+        if (pt.right) pt.right.parent = pt;
+        right.parent = pt.parent;
+
+        if (!pt.parent) this.root = right;
+        else if (pt === pt.parent.left) pt.parent.left = right;
+        else pt.parent.right = right;
+
+        right.left = pt;
+        pt.parent = right;
+    }
+
+    rotateRight(pt: RBTreeNode<T>): void {
+        const left = pt.left!;
+        pt.left = left.right;
+
+        if (pt.left) pt.left.parent = pt;
+        left.parent = pt.parent;
+
+        if (!pt.parent) this.root = left;
+        else if (pt === pt.parent.left) pt.parent.left = left;
+        else pt.parent.right = left;
+
+        left.right = pt;
+        pt.parent = left;
+    }
+
+    swapColor(p1: RBTreeNode<T>, p2: RBTreeNode<T>): void {
+        const tmp = p1.color;
+        p1.color = p2.color;
+        p2.color = tmp;
+    }
+
+    swapData(p1: RBTreeNode<T>, p2: RBTreeNode<T>): void {
+        const tmp = p1.data;
+        p1.data = p2.data;
+        p2.data = tmp;
+    }
+
+    fixAfterInsert(pt: RBTreeNode<T>): void {
+        let parent = null;
+        let grandParent = null;
+
+        while (pt !== this.root && pt.color !== 1 && pt.parent?.color === 0) {
+            parent = pt.parent;
+            grandParent = pt.parent.parent;
+
+            /*  Case : A
+                Parent of pt is left child of Grand-parent of pt */
+            if (parent === grandParent?.left) {
+                const uncle = grandParent.right;
+
+                /* Case : 1
+                   The uncle of pt is also red
+                   Only Recoloring required */
+                if (uncle && uncle.color === 0) {
+                    grandParent.color = 0;
+                    parent.color = 1;
+                    uncle.color = 1;
+                    pt = grandParent;
+                } else {
+                    /* Case : 2
+                       pt is right child of its parent
+                       Left-rotation required */
+                    if (pt === parent.right) {
+                        this.rotateLeft(parent);
+                        pt = parent;
+                        parent = pt.parent;
+                    }
+
+                    /* Case : 3
+                       pt is left child of its parent
+                       Right-rotation required */
+                    this.rotateRight(grandParent);
+                    this.swapColor(parent!, grandParent);
+                    pt = parent!;
+                }
+            } else {
+                /* Case : B
+               Parent of pt is right child of Grand-parent of pt */
+                const uncle = grandParent!.left;
+
+                /*  Case : 1
+                    The uncle of pt is also red
+                    Only Recoloring required */
+                if (uncle != null && uncle.color === 0) {
+                    grandParent!.color = 0;
+                    parent.color = 1;
+                    uncle.color = 1;
+                    pt = grandParent!;
+                } else {
+                    /* Case : 2
+                       pt is left child of its parent
+                       Right-rotation required */
+                    if (pt === parent.left) {
+                        this.rotateRight(parent);
+                        pt = parent;
+                        parent = pt.parent;
+                    }
+
+                    /* Case : 3
+                       pt is right child of its parent
+                       Left-rotation required */
+                    this.rotateLeft(grandParent!);
+                    this.swapColor(parent!, grandParent!);
+                    pt = parent!;
+                }
+            }
+        }
+        this.root!.color = 1;
+    }
+
+    delete(val: T): boolean {
+        const node = this.find(val);
+        if (!node) return false;
+        node.count--;
+        if (!node.count) this.deleteNode(node);
+        return true;
+    }
+
+    deleteAll(val: T): boolean {
+        const node = this.find(val);
+        if (!node) return false;
+        this.deleteNode(node);
+        return true;
+    }
+
+    deleteNode(v: RBTreeNode<T>): void {
+        const u = BSTreplace(v);
+
+        // True when u and v are both black
+        const uvBlack = (u === null || u.color === 1) && v.color === 1;
+        const parent = v.parent!;
+
+        if (!u) {
+            // u is null therefore v is leaf
+            if (v === this.root) this.root = null;
+            // v is root, making root null
+            else {
+                if (uvBlack) {
+                    // u and v both black
+                    // v is leaf, fix double black at v
+                    this.fixDoubleBlack(v);
+                } else {
+                    // u or v is red
+                    if (v.sibling()) {
+                        // sibling is not null, make it red"
+                        v.sibling()!.color = 0;
+                    }
+                }
+                // delete v from the tree
+                if (v.isOnLeft()) parent.left = null;
+                else parent.right = null;
+            }
+            return;
+        }
+
+        if (!v.left || !v.right) {
+            // v has 1 child
+            if (v === this.root) {
+                // v is root, assign the value of u to v, and delete u
+                v.data = u.data;
+                v.left = v.right = null;
+            } else {
+                // Detach v from tree and move u up
+                if (v.isOnLeft()) parent.left = u;
+                else parent.right = u;
+                u.parent = parent;
+                if (uvBlack) this.fixDoubleBlack(u);
+                // u and v both black, fix double black at u
+                else u.color = 1; // u or v red, color u black
+            }
+            return;
+        }
+
+        // v has 2 children, swap data with successor and recurse
+        this.swapData(u, v);
+        this.deleteNode(u);
+
+        // find node that replaces a deleted node in BST
+        function BSTreplace(x: RBTreeNode<T>): RBTreeNode<T> | null {
+            // when node have 2 children
+            if (x.left && x.right) return successor(x.right);
+            // when leaf
+            if (!x.left && !x.right) return null;
+            // when single child
+            return x.left ?? x.right;
+        }
+        // find node that do not have a left child
+        // in the subtree of the given node
+        function successor(x: RBTreeNode<T>): RBTreeNode<T> {
+            let temp = x;
+            while (temp.left) temp = temp.left;
+            return temp;
+        }
+    }
+
+    fixDoubleBlack(x: RBTreeNode<T>): void {
+        if (x === this.root) return; // Reached root
+
+        const sibling = x.sibling();
+        const parent = x.parent!;
+        if (!sibling) {
+            // No sibiling, double black pushed up
+            this.fixDoubleBlack(parent);
+        } else {
+            if (sibling.color === 0) {
+                // Sibling red
+                parent.color = 0;
+                sibling.color = 1;
+                if (sibling.isOnLeft()) this.rotateRight(parent);
+                // left case
+                else this.rotateLeft(parent); // right case
+                this.fixDoubleBlack(x);
+            } else {
+                // Sibling black
+                if (sibling.hasRedChild()) {
+                    // at least 1 red children
+                    if (sibling.left && sibling.left.color === 0) {
+                        if (sibling.isOnLeft()) {
+                            // left left
+                            sibling.left.color = sibling.color;
+                            sibling.color = parent.color;
+                            this.rotateRight(parent);
+                        } else {
+                            // right left
+                            sibling.left.color = parent.color;
+                            this.rotateRight(sibling);
+                            this.rotateLeft(parent);
+                        }
+                    } else {
+                        if (sibling.isOnLeft()) {
+                            // left right
+                            sibling.right!.color = parent.color;
+                            this.rotateLeft(sibling);
+                            this.rotateRight(parent);
+                        } else {
+                            // right right
+                            sibling.right!.color = sibling.color;
+                            sibling.color = parent.color;
+                            this.rotateLeft(parent);
+                        }
+                    }
+                    parent.color = 1;
+                } else {
+                    // 2 black children
+                    sibling.color = 0;
+                    if (parent.color === 1) this.fixDoubleBlack(parent);
+                    else parent.color = 1;
+                }
+            }
+        }
+    }
+
+    insert(data: T): boolean {
+        // search for a position to insert
+        let parent = this.root;
+        while (parent) {
+            if (this.lt(data, parent.data)) {
+                if (!parent.left) break;
+                else parent = parent.left;
+            } else if (this.lt(parent.data, data)) {
+                if (!parent.right) break;
+                else parent = parent.right;
+            } else break;
+        }
+
+        // insert node into parent
+        const node = new RBTreeNode(data);
+        if (!parent) this.root = node;
+        else if (this.lt(node.data, parent.data)) parent.left = node;
+        else if (this.lt(parent.data, node.data)) parent.right = node;
+        else {
+            parent.count++;
+            return false;
+        }
+        node.parent = parent;
+        this.fixAfterInsert(node);
+        return true;
+    }
+
+    find(data: T): RBTreeNode<T> | null {
+        let p = this.root;
+        while (p) {
+            if (this.lt(data, p.data)) {
+                p = p.left;
+            } else if (this.lt(p.data, data)) {
+                p = p.right;
+            } else break;
+        }
+        return p ?? null;
+    }
+
+    *inOrder(root: RBTreeNode<T> = this.root!): Generator<T, undefined, void> {
+        if (!root) return;
+        for (const v of this.inOrder(root.left!)) yield v;
+        yield root.data;
+        for (const v of this.inOrder(root.right!)) yield v;
+    }
+
+    *reverseInOrder(root: RBTreeNode<T> = this.root!): Generator<T, undefined, void> {
+        if (!root) return;
+        for (const v of this.reverseInOrder(root.right!)) yield v;
+        yield root.data;
+        for (const v of this.reverseInOrder(root.left!)) yield v;
+    }
+}
+
+class TreeSet<T = number> {
+    _size: number;
+    tree: RBTree<T>;
+    compare: Compare<T>;
+    constructor(
+        collection: T[] | Compare<T> = [],
+        compare: Compare<T> = (l: T, r: T) => (l < r ? -1 : l > r ? 1 : 0),
+    ) {
+        if (typeof collection === 'function') {
+            compare = collection;
+            collection = [];
+        }
+        this._size = 0;
+        this.compare = compare;
+        this.tree = new RBTree(compare);
+        for (const val of collection) this.add(val);
+    }
+
+    size(): number {
+        return this._size;
+    }
+
+    has(val: T): boolean {
+        return !!this.tree.find(val);
+    }
+
+    add(val: T): boolean {
+        const successful = this.tree.insert(val);
+        this._size += successful ? 1 : 0;
+        return successful;
+    }
+
+    delete(val: T): boolean {
+        const deleted = this.tree.deleteAll(val);
+        this._size -= deleted ? 1 : 0;
+        return deleted;
+    }
+
+    ceil(val: T): T | undefined {
+        let p = this.tree.root;
+        let higher = null;
+        while (p) {
+            if (this.compare(p.data, val) >= 0) {
+                higher = p;
+                p = p.left;
+            } else {
+                p = p.right;
+            }
+        }
+        return higher?.data;
+    }
+
+    floor(val: T): T | undefined {
+        let p = this.tree.root;
+        let lower = null;
+        while (p) {
+            if (this.compare(val, p.data) >= 0) {
+                lower = p;
+                p = p.right;
+            } else {
+                p = p.left;
+            }
+        }
+        return lower?.data;
+    }
+
+    higher(val: T): T | undefined {
+        let p = this.tree.root;
+        let higher = null;
+        while (p) {
+            if (this.compare(val, p.data) < 0) {
+                higher = p;
+                p = p.left;
+            } else {
+                p = p.right;
+            }
+        }
+        return higher?.data;
+    }
+
+    lower(val: T): T | undefined {
+        let p = this.tree.root;
+        let lower = null;
+        while (p) {
+            if (this.compare(p.data, val) < 0) {
+                lower = p;
+                p = p.right;
+            } else {
+                p = p.left;
+            }
+        }
+        return lower?.data;
+    }
+
+    first(): T | undefined {
+        return this.tree.inOrder().next().value;
+    }
+
+    last(): T | undefined {
+        return this.tree.reverseInOrder().next().value;
+    }
+
+    shift(): T | undefined {
+        const first = this.first();
+        if (first === undefined) return undefined;
+        this.delete(first);
+        return first;
+    }
+
+    pop(): T | undefined {
+        const last = this.last();
+        if (last === undefined) return undefined;
+        this.delete(last);
+        return last;
+    }
+
+    *[Symbol.iterator](): Generator<T, void, void> {
+        for (const val of this.values()) yield val;
+    }
+
+    *keys(): Generator<T, void, void> {
+        for (const val of this.values()) yield val;
+    }
+
+    *values(): Generator<T, undefined, void> {
+        for (const val of this.tree.inOrder()) yield val;
+        return undefined;
+    }
+
+    /**
+     * Return a generator for reverse order traversing the set
+     */
+    *rvalues(): Generator<T, undefined, void> {
+        for (const val of this.tree.reverseInOrder()) yield val;
+        return undefined;
+    }
+}
+
+/**
+ * Your ExamRoom object will be instantiated and called as such:
+ * var obj = new ExamRoom(n)
+ * var param_1 = obj.seat()
+ * obj.leave(p)
+ */
+```
+
 <!-- tabs:end -->
 
 <!-- solution:end -->
diff --git a/solution/0800-0899/0855.Exam Room/Solution.ts b/solution/0800-0899/0855.Exam Room/Solution.ts
new file mode 100644
index 0000000000000..f4ece5ee92d91
--- /dev/null
+++ b/solution/0800-0899/0855.Exam Room/Solution.ts	
@@ -0,0 +1,551 @@
+class ExamRoom {
+    private ts: TreeSet<number[]> = new TreeSet<number[]>((a, b) => {
+        const d1 = this.dist(a),
+            d2 = this.dist(b);
+        return d1 === d2 ? a[0] - b[0] : d2 - d1;
+    });
+    private left: Map<number, number> = new Map();
+    private right: Map<number, number> = new Map();
+    private n: number;
+
+    constructor(n: number) {
+        this.n = n;
+        this.add([-1, n]);
+    }
+
+    seat(): number {
+        const s = this.ts.first();
+        let p = Math.floor((s[0] + s[1]) / 2);
+        if (s[0] === -1) {
+            p = 0;
+        } else if (s[1] === this.n) {
+            p = this.n - 1;
+        }
+        this.del(s);
+        this.add([s[0], p]);
+        this.add([p, s[1]]);
+        return p;
+    }
+
+    leave(p: number): void {
+        const l = this.left.get(p)!;
+        const r = this.right.get(p)!;
+        this.del([l, p]);
+        this.del([p, r]);
+        this.add([l, r]);
+    }
+
+    private dist(s: number[]): number {
+        const [l, r] = s;
+        return l === -1 || r === this.n ? r - l - 1 : Math.floor((r - l) / 2);
+    }
+
+    private add(s: number[]): void {
+        this.ts.add(s);
+        this.left.set(s[1], s[0]);
+        this.right.set(s[0], s[1]);
+    }
+
+    private del(s: number[]): void {
+        this.ts.delete(s);
+        this.left.delete(s[1]);
+        this.right.delete(s[0]);
+    }
+}
+
+type Compare<T> = (lhs: T, rhs: T) => number;
+
+class RBTreeNode<T = number> {
+    data: T;
+    count: number;
+    left: RBTreeNode<T> | null;
+    right: RBTreeNode<T> | null;
+    parent: RBTreeNode<T> | null;
+    color: number;
+    constructor(data: T) {
+        this.data = data;
+        this.left = this.right = this.parent = null;
+        this.color = 0;
+        this.count = 1;
+    }
+
+    sibling(): RBTreeNode<T> | null {
+        if (!this.parent) return null; // sibling null if no parent
+        return this.isOnLeft() ? this.parent.right : this.parent.left;
+    }
+
+    isOnLeft(): boolean {
+        return this === this.parent!.left;
+    }
+
+    hasRedChild(): boolean {
+        return (
+            Boolean(this.left && this.left.color === 0) ||
+            Boolean(this.right && this.right.color === 0)
+        );
+    }
+}
+
+class RBTree<T> {
+    root: RBTreeNode<T> | null;
+    lt: (l: T, r: T) => boolean;
+    constructor(compare: Compare<T> = (l: T, r: T) => (l < r ? -1 : l > r ? 1 : 0)) {
+        this.root = null;
+        this.lt = (l: T, r: T) => compare(l, r) < 0;
+    }
+
+    rotateLeft(pt: RBTreeNode<T>): void {
+        const right = pt.right!;
+        pt.right = right.left;
+
+        if (pt.right) pt.right.parent = pt;
+        right.parent = pt.parent;
+
+        if (!pt.parent) this.root = right;
+        else if (pt === pt.parent.left) pt.parent.left = right;
+        else pt.parent.right = right;
+
+        right.left = pt;
+        pt.parent = right;
+    }
+
+    rotateRight(pt: RBTreeNode<T>): void {
+        const left = pt.left!;
+        pt.left = left.right;
+
+        if (pt.left) pt.left.parent = pt;
+        left.parent = pt.parent;
+
+        if (!pt.parent) this.root = left;
+        else if (pt === pt.parent.left) pt.parent.left = left;
+        else pt.parent.right = left;
+
+        left.right = pt;
+        pt.parent = left;
+    }
+
+    swapColor(p1: RBTreeNode<T>, p2: RBTreeNode<T>): void {
+        const tmp = p1.color;
+        p1.color = p2.color;
+        p2.color = tmp;
+    }
+
+    swapData(p1: RBTreeNode<T>, p2: RBTreeNode<T>): void {
+        const tmp = p1.data;
+        p1.data = p2.data;
+        p2.data = tmp;
+    }
+
+    fixAfterInsert(pt: RBTreeNode<T>): void {
+        let parent = null;
+        let grandParent = null;
+
+        while (pt !== this.root && pt.color !== 1 && pt.parent?.color === 0) {
+            parent = pt.parent;
+            grandParent = pt.parent.parent;
+
+            /*  Case : A
+                Parent of pt is left child of Grand-parent of pt */
+            if (parent === grandParent?.left) {
+                const uncle = grandParent.right;
+
+                /* Case : 1
+                   The uncle of pt is also red
+                   Only Recoloring required */
+                if (uncle && uncle.color === 0) {
+                    grandParent.color = 0;
+                    parent.color = 1;
+                    uncle.color = 1;
+                    pt = grandParent;
+                } else {
+                    /* Case : 2
+                       pt is right child of its parent
+                       Left-rotation required */
+                    if (pt === parent.right) {
+                        this.rotateLeft(parent);
+                        pt = parent;
+                        parent = pt.parent;
+                    }
+
+                    /* Case : 3
+                       pt is left child of its parent
+                       Right-rotation required */
+                    this.rotateRight(grandParent);
+                    this.swapColor(parent!, grandParent);
+                    pt = parent!;
+                }
+            } else {
+                /* Case : B
+               Parent of pt is right child of Grand-parent of pt */
+                const uncle = grandParent!.left;
+
+                /*  Case : 1
+                    The uncle of pt is also red
+                    Only Recoloring required */
+                if (uncle != null && uncle.color === 0) {
+                    grandParent!.color = 0;
+                    parent.color = 1;
+                    uncle.color = 1;
+                    pt = grandParent!;
+                } else {
+                    /* Case : 2
+                       pt is left child of its parent
+                       Right-rotation required */
+                    if (pt === parent.left) {
+                        this.rotateRight(parent);
+                        pt = parent;
+                        parent = pt.parent;
+                    }
+
+                    /* Case : 3
+                       pt is right child of its parent
+                       Left-rotation required */
+                    this.rotateLeft(grandParent!);
+                    this.swapColor(parent!, grandParent!);
+                    pt = parent!;
+                }
+            }
+        }
+        this.root!.color = 1;
+    }
+
+    delete(val: T): boolean {
+        const node = this.find(val);
+        if (!node) return false;
+        node.count--;
+        if (!node.count) this.deleteNode(node);
+        return true;
+    }
+
+    deleteAll(val: T): boolean {
+        const node = this.find(val);
+        if (!node) return false;
+        this.deleteNode(node);
+        return true;
+    }
+
+    deleteNode(v: RBTreeNode<T>): void {
+        const u = BSTreplace(v);
+
+        // True when u and v are both black
+        const uvBlack = (u === null || u.color === 1) && v.color === 1;
+        const parent = v.parent!;
+
+        if (!u) {
+            // u is null therefore v is leaf
+            if (v === this.root) this.root = null;
+            // v is root, making root null
+            else {
+                if (uvBlack) {
+                    // u and v both black
+                    // v is leaf, fix double black at v
+                    this.fixDoubleBlack(v);
+                } else {
+                    // u or v is red
+                    if (v.sibling()) {
+                        // sibling is not null, make it red"
+                        v.sibling()!.color = 0;
+                    }
+                }
+                // delete v from the tree
+                if (v.isOnLeft()) parent.left = null;
+                else parent.right = null;
+            }
+            return;
+        }
+
+        if (!v.left || !v.right) {
+            // v has 1 child
+            if (v === this.root) {
+                // v is root, assign the value of u to v, and delete u
+                v.data = u.data;
+                v.left = v.right = null;
+            } else {
+                // Detach v from tree and move u up
+                if (v.isOnLeft()) parent.left = u;
+                else parent.right = u;
+                u.parent = parent;
+                if (uvBlack) this.fixDoubleBlack(u);
+                // u and v both black, fix double black at u
+                else u.color = 1; // u or v red, color u black
+            }
+            return;
+        }
+
+        // v has 2 children, swap data with successor and recurse
+        this.swapData(u, v);
+        this.deleteNode(u);
+
+        // find node that replaces a deleted node in BST
+        function BSTreplace(x: RBTreeNode<T>): RBTreeNode<T> | null {
+            // when node have 2 children
+            if (x.left && x.right) return successor(x.right);
+            // when leaf
+            if (!x.left && !x.right) return null;
+            // when single child
+            return x.left ?? x.right;
+        }
+        // find node that do not have a left child
+        // in the subtree of the given node
+        function successor(x: RBTreeNode<T>): RBTreeNode<T> {
+            let temp = x;
+            while (temp.left) temp = temp.left;
+            return temp;
+        }
+    }
+
+    fixDoubleBlack(x: RBTreeNode<T>): void {
+        if (x === this.root) return; // Reached root
+
+        const sibling = x.sibling();
+        const parent = x.parent!;
+        if (!sibling) {
+            // No sibiling, double black pushed up
+            this.fixDoubleBlack(parent);
+        } else {
+            if (sibling.color === 0) {
+                // Sibling red
+                parent.color = 0;
+                sibling.color = 1;
+                if (sibling.isOnLeft()) this.rotateRight(parent);
+                // left case
+                else this.rotateLeft(parent); // right case
+                this.fixDoubleBlack(x);
+            } else {
+                // Sibling black
+                if (sibling.hasRedChild()) {
+                    // at least 1 red children
+                    if (sibling.left && sibling.left.color === 0) {
+                        if (sibling.isOnLeft()) {
+                            // left left
+                            sibling.left.color = sibling.color;
+                            sibling.color = parent.color;
+                            this.rotateRight(parent);
+                        } else {
+                            // right left
+                            sibling.left.color = parent.color;
+                            this.rotateRight(sibling);
+                            this.rotateLeft(parent);
+                        }
+                    } else {
+                        if (sibling.isOnLeft()) {
+                            // left right
+                            sibling.right!.color = parent.color;
+                            this.rotateLeft(sibling);
+                            this.rotateRight(parent);
+                        } else {
+                            // right right
+                            sibling.right!.color = sibling.color;
+                            sibling.color = parent.color;
+                            this.rotateLeft(parent);
+                        }
+                    }
+                    parent.color = 1;
+                } else {
+                    // 2 black children
+                    sibling.color = 0;
+                    if (parent.color === 1) this.fixDoubleBlack(parent);
+                    else parent.color = 1;
+                }
+            }
+        }
+    }
+
+    insert(data: T): boolean {
+        // search for a position to insert
+        let parent = this.root;
+        while (parent) {
+            if (this.lt(data, parent.data)) {
+                if (!parent.left) break;
+                else parent = parent.left;
+            } else if (this.lt(parent.data, data)) {
+                if (!parent.right) break;
+                else parent = parent.right;
+            } else break;
+        }
+
+        // insert node into parent
+        const node = new RBTreeNode(data);
+        if (!parent) this.root = node;
+        else if (this.lt(node.data, parent.data)) parent.left = node;
+        else if (this.lt(parent.data, node.data)) parent.right = node;
+        else {
+            parent.count++;
+            return false;
+        }
+        node.parent = parent;
+        this.fixAfterInsert(node);
+        return true;
+    }
+
+    find(data: T): RBTreeNode<T> | null {
+        let p = this.root;
+        while (p) {
+            if (this.lt(data, p.data)) {
+                p = p.left;
+            } else if (this.lt(p.data, data)) {
+                p = p.right;
+            } else break;
+        }
+        return p ?? null;
+    }
+
+    *inOrder(root: RBTreeNode<T> = this.root!): Generator<T, undefined, void> {
+        if (!root) return;
+        for (const v of this.inOrder(root.left!)) yield v;
+        yield root.data;
+        for (const v of this.inOrder(root.right!)) yield v;
+    }
+
+    *reverseInOrder(root: RBTreeNode<T> = this.root!): Generator<T, undefined, void> {
+        if (!root) return;
+        for (const v of this.reverseInOrder(root.right!)) yield v;
+        yield root.data;
+        for (const v of this.reverseInOrder(root.left!)) yield v;
+    }
+}
+
+class TreeSet<T = number> {
+    _size: number;
+    tree: RBTree<T>;
+    compare: Compare<T>;
+    constructor(
+        collection: T[] | Compare<T> = [],
+        compare: Compare<T> = (l: T, r: T) => (l < r ? -1 : l > r ? 1 : 0),
+    ) {
+        if (typeof collection === 'function') {
+            compare = collection;
+            collection = [];
+        }
+        this._size = 0;
+        this.compare = compare;
+        this.tree = new RBTree(compare);
+        for (const val of collection) this.add(val);
+    }
+
+    size(): number {
+        return this._size;
+    }
+
+    has(val: T): boolean {
+        return !!this.tree.find(val);
+    }
+
+    add(val: T): boolean {
+        const successful = this.tree.insert(val);
+        this._size += successful ? 1 : 0;
+        return successful;
+    }
+
+    delete(val: T): boolean {
+        const deleted = this.tree.deleteAll(val);
+        this._size -= deleted ? 1 : 0;
+        return deleted;
+    }
+
+    ceil(val: T): T | undefined {
+        let p = this.tree.root;
+        let higher = null;
+        while (p) {
+            if (this.compare(p.data, val) >= 0) {
+                higher = p;
+                p = p.left;
+            } else {
+                p = p.right;
+            }
+        }
+        return higher?.data;
+    }
+
+    floor(val: T): T | undefined {
+        let p = this.tree.root;
+        let lower = null;
+        while (p) {
+            if (this.compare(val, p.data) >= 0) {
+                lower = p;
+                p = p.right;
+            } else {
+                p = p.left;
+            }
+        }
+        return lower?.data;
+    }
+
+    higher(val: T): T | undefined {
+        let p = this.tree.root;
+        let higher = null;
+        while (p) {
+            if (this.compare(val, p.data) < 0) {
+                higher = p;
+                p = p.left;
+            } else {
+                p = p.right;
+            }
+        }
+        return higher?.data;
+    }
+
+    lower(val: T): T | undefined {
+        let p = this.tree.root;
+        let lower = null;
+        while (p) {
+            if (this.compare(p.data, val) < 0) {
+                lower = p;
+                p = p.right;
+            } else {
+                p = p.left;
+            }
+        }
+        return lower?.data;
+    }
+
+    first(): T | undefined {
+        return this.tree.inOrder().next().value;
+    }
+
+    last(): T | undefined {
+        return this.tree.reverseInOrder().next().value;
+    }
+
+    shift(): T | undefined {
+        const first = this.first();
+        if (first === undefined) return undefined;
+        this.delete(first);
+        return first;
+    }
+
+    pop(): T | undefined {
+        const last = this.last();
+        if (last === undefined) return undefined;
+        this.delete(last);
+        return last;
+    }
+
+    *[Symbol.iterator](): Generator<T, void, void> {
+        for (const val of this.values()) yield val;
+    }
+
+    *keys(): Generator<T, void, void> {
+        for (const val of this.values()) yield val;
+    }
+
+    *values(): Generator<T, undefined, void> {
+        for (const val of this.tree.inOrder()) yield val;
+        return undefined;
+    }
+
+    /**
+     * Return a generator for reverse order traversing the set
+     */
+    *rvalues(): Generator<T, undefined, void> {
+        for (const val of this.tree.reverseInOrder()) yield val;
+        return undefined;
+    }
+}
+
+/**
+ * Your ExamRoom object will be instantiated and called as such:
+ * var obj = new ExamRoom(n)
+ * var param_1 = obj.seat()
+ * obj.leave(p)
+ */