data-structure-typed 0.8.6

package/src/data-structures/queue/deque.ts

@@ -0,0 +1,139 @@
+import {DoublyLinkedList} from '../linked-list';
+
+// O(n) time complexity of obtaining the value
+// O(1) time complexity of adding at the beginning and the end
+export class Deque<T> extends DoublyLinkedList<T> {
+
+}
+
+// O(1) time complexity of obtaining the value
+// O(n) time complexity of adding at the beginning and the end
+// todo tested slowest one
+export class ObjectDeque<T> {
+    protected _nodes: { [key: number]: T } = {};
+    protected _capacity = Number.MAX_SAFE_INTEGER;
+    protected _first: number = -1;
+    protected _last: number = -1;
+    protected _size: number = 0;
+
+    constructor(capacity?: number) {
+        if (capacity !== undefined) this._capacity = capacity;
+    }
+
+    size() {
+        return this._size;
+    }
+
+    offerFirst(value: T) {
+        if (this._size === 0) {
+            const mid = Math.floor(this._capacity / 2);
+            this._first = mid;
+            this._last = mid;
+        } else {
+            this._first--;
+        }
+        this._nodes[this._first] = value;
+        this._size++;
+    }
+
+    offerLast(value: T) {
+        if (this._size === 0) {
+            const mid = Math.floor(this._capacity / 2);
+            this._first = mid;
+            this._last = mid;
+        } else {
+            this._last++;
+        }
+        this._nodes[this._last] = value;
+        this._size++;
+    }
+
+    pollFirst() {
+        if (!this._size) return;
+        let value = this.peekFirst();
+        delete this._nodes[this._first];
+        this._first++;
+        this._size--;
+        return value;
+    }
+
+    peekFirst() {
+        if (this._size) return this._nodes[this._first];
+    }
+
+    pollLast() {
+        if (!this._size) return;
+        let value = this.peekLast();
+        delete this._nodes[this._last];
+        this._last--;
+        this._size--;
+
+        return value;
+    }
+
+    peekLast() {
+        if (this._size) return this._nodes[this._last];
+    }
+
+    get(index: number) {
+        return this._nodes[this._first + index] || null;
+    }
+
+    isEmpty() {
+        return this._size <= 0;
+    }
+}
+
+// O(1) time complexity of obtaining the value
+// O(n) time complexity of adding at the beginning and the end
+export class ArrayDeque<T> {
+    protected _nodes: T[] = [];
+
+    get size() {
+        return this._nodes.length;
+    }
+
+    offerLast(value: T) {
+        return this._nodes.push(value);
+    }
+
+    pollLast(): T | null {
+        return this._nodes.pop() ?? null;
+    }
+
+    pollFirst(): T | null {
+        return this._nodes.shift() ?? null;
+    }
+
+    offerFirst(value: T) {
+        return this._nodes.unshift(value);
+    }
+
+    peekFirst(): T | null {
+        return this._nodes[0] ?? null;
+    }
+
+    peekLast(): T | null {
+        return this._nodes[this._nodes.length - 1] ?? null;
+    }
+
+    get(index: number): T | null {
+        return this._nodes[index] ?? null;
+    }
+
+    set(index: number, value: T) {
+        return this._nodes[index] = value;
+    }
+
+    insert(index: number, value: T) {
+        return this._nodes.splice(index, 0, value);
+    }
+
+    remove(index: number) {
+        return this._nodes.splice(index, 1);
+    }
+
+    isEmpty() {
+        return this._nodes.length === 0;
+    }
+}

package/src/data-structures/queue/index.ts

@@ -0,0 +1 @@
+export * from './queue';

package/src/data-structures/queue/queue.ts

@@ -0,0 +1,123 @@
+/**
+ * @license MIT
+ * @copyright 2020 Pablo
+ *
+ * @class
+ */
+export class Queue<T> {
+    protected _nodes: T[];
+    protected _offset: number;
+
+    /**
+     * Creates a queue.
+     * @param {array} [elements]
+     */
+    constructor(elements?: T[]) {
+        this._nodes = elements || [];
+        this._offset = 0;
+    }
+
+    /**
+     * Adds an element at the back of the queue.
+     * @public
+     * @param {any} element
+     */
+    offer(element: T): Queue<T> {
+        this._nodes.push(element);
+        return this;
+    }
+
+    /**
+     * Dequeues the front element in the queue.
+     * @public
+     * @returns {any}
+     */
+    poll(): T | null {
+        if (this.size() === 0) return null;
+
+        const first = this.peek();
+        this._offset += 1;
+
+        if (this._offset * 2 < this._nodes.length) return first;
+
+        // only remove dequeued elements when reaching half size
+        // to decrease latency of shifting elements.
+        this._nodes = this._nodes.slice(this._offset);
+        this._offset = 0;
+        return first;
+    }
+
+    /**
+     * Returns the front element of the queue.
+     * @public
+     * @returns {any}
+     */
+    peek(): T | null {
+        return this.size() > 0 ? this._nodes[this._offset] : null;
+    }
+
+    /**
+     * Returns the back element of the queue.
+     * @public
+     * @returns {any}
+     */
+    peekLast(): T | null {
+        return this.size() > 0 ? this._nodes[this._nodes.length - 1] : null;
+    }
+
+    /**
+     * Returns the number of elements in the queue.
+     * @public
+     * @returns {number}
+     */
+    size(): number {
+        return this._nodes.length - this._offset;
+    }
+
+    /**
+     * Checks if the queue is empty.
+     * @public
+     * @returns {boolean}
+     */
+    isEmpty(): boolean {
+        return this.size() === 0;
+    }
+
+    /**
+     * Returns the remaining elements in the queue as an array.
+     * @public
+     * @returns {array}
+     */
+    toArray(): T[] {
+        return this._nodes.slice(this._offset);
+    }
+
+    /**
+     * Clears the queue.
+     * @public
+     */
+    clear(): void {
+        this._nodes = [];
+        this._offset = 0;
+    }
+
+    /**
+     * Creates a shallow copy of the queue.
+     * @public
+     * @return {Queue}
+     */
+    clone(): Queue<T> {
+        return new Queue(this._nodes.slice(this._offset));
+    }
+
+    /**
+     * Creates a queue from an existing array.
+     * @public
+     * @static
+     * @param {array} elements
+     * @return {Queue}
+     */
+    static fromArray<T>(elements: T[]): Queue<T> {
+        return new Queue(elements);
+    }
+}

package/src/data-structures/stack/index.ts

@@ -0,0 +1 @@
+export * from './stack';

package/src/data-structures/stack/stack.ts

@@ -0,0 +1,104 @@
+/**
+ * @license MIT
+ * @copyright 2020 Pablo Rios <zrwusa@gmail.com>
+ *
+ * @class
+ */
+export class Stack<T> {
+    protected _elements: T[];
+
+    /**
+     * Creates a stack.
+     * @param {array} [elements]
+     */
+    constructor(elements?: T[]) {
+        this._elements = Array.isArray(elements) ? elements : [];
+    }
+
+    /**
+     * Checks if the stack is empty.
+     * @public
+     * @returns {boolean}
+     */
+    isEmpty(): boolean {
+        return this._elements.length === 0;
+    }
+
+    /**
+     * Returns the number of elements in the stack.
+     * @public
+     * @returns {number}
+     */
+    size(): number {
+        return this._elements.length;
+    }
+
+    /**
+     * Returns the top element in the stack.
+     * @public
+     * @returns {object}
+     */
+    peek(): T | null {
+        if (this.isEmpty()) return null;
+
+        return this._elements[this._elements.length - 1];
+    }
+
+    /**
+     * Adds an element to the top of the stack.
+     * @public
+     * @param {object} element
+     */
+    push(element: T): Stack<T> {
+        this._elements.push(element);
+        return this;
+    }
+
+    /**
+     * Removes and returns the top element in the stack.
+     * @public
+     * @returns {object}
+     */
+    pop(): T | null {
+        if (this.isEmpty()) return null;
+
+        return this._elements.pop() || null;
+    }
+
+    /**
+     * Returns the remaining elements as an array.
+     * @public
+     * @returns {array}
+     */
+    toArray(): T[] {
+        return this._elements.slice();
+    }
+
+    /**
+     * Clears all elements from the stack.
+     * @public
+     */
+    clear(): void {
+        this._elements = [];
+    }
+
+    /**
+     * Creates a shallow copy from the stack.
+     * @public
+     * @return {Stack}
+     */
+    clone(): Stack<T> {
+        return new Stack(this._elements.slice());
+    }
+
+    /**
+     * Creates a stack from an existing array
+     * @public
+     * @static
+     * @param {array} [elements]
+     * @return {Stack}
+     */
+    static fromArray<T>(elements: T[]): Stack<T> {
+        return new Stack(elements);
+    }
+}

package/src/data-structures/trampoline.ts

@@ -0,0 +1,91 @@
+export type ArgumentTypes<T extends (...args: any[]) => any> =
+    T extends (...args: infer A) => any
+        ? A
+        : never;
+
+export const THUNK_SYMBOL: unique symbol = Symbol('thunk');
+
+export interface Thunk<T> extends Function {
+    __THUNK__: typeof THUNK_SYMBOL;
+
+    (): T;
+}
+
+export type ThunkOrValue<T> = T | Thunk<T>;
+
+export type UnwrapThunkDeep<T> = {
+    0: T extends Thunk<infer U> ? UnwrapThunkDeep<U> : T;
+}[
+    T extends ThunkOrValue<T> ? 0 : never
+    ];
+
+export const isThunk = <T>(value: any): value is Thunk<T> => {
+    return typeof value === 'function' && value.__THUNK__ === THUNK_SYMBOL;
+};
+
+export const toThunk = <R>(fn: () => R): Thunk<R> => {
+    const thunk = () => fn();
+    thunk.__THUNK__ = THUNK_SYMBOL;
+    return thunk;
+};
+export type UnwrapPromise<T> = T extends Promise<infer U> ? Exclude<U, Promise<T>> : T;
+
+export type Unbox<T> = UnwrapThunkDeep<UnwrapPromise<T>>;
+
+export type Cont<A extends any[], R> = (...args: A) => Thunk<Unbox<R>>;
+
+export interface Trampoline<F extends ((...args: any[]) => any)> {
+    (...args: ArgumentTypes<F>): Unbox<ReturnType<F>>;
+
+    cont: Cont<ArgumentTypes<F>, ReturnType<F>>;
+}
+
+export interface TrampolineAsync<F extends ((...args: any[]) => any)> {
+    (...args: ArgumentTypes<F>): Promise<Unbox<ReturnType<F>>>;
+
+    cont: Cont<ArgumentTypes<F>, ReturnType<F>>;
+}
+
+export const trampoline = <F extends ((...args: any[]) => any)>(fn: F): Trampoline<F> => {
+    const cont = (...args: ArgumentTypes<F>) => toThunk(() => fn(...args));
+
+    return Object.assign(
+        (...args: ArgumentTypes<F>): Unbox<ReturnType<F>> => {
+            let result: ThunkOrValue<ReturnType<F>> = fn(...args);
+
+            while (isThunk<ReturnType<F>>(result)) {
+                result = result();
+            }
+
+            return result;
+        },
+        {cont},
+    );
+};
+
+export const trampolineAsync = <F extends ((...args: any[]) => any)>(fn: F): TrampolineAsync<F> => {
+    const cont = (...args: ArgumentTypes<F>) => toThunk(() => fn(...args));
+
+    return Object.assign(
+        async (...args: ArgumentTypes<F>): Promise<Unbox<ReturnType<F>>> => {
+            let result: ThunkOrValue<ReturnType<F>> = await fn(...args);
+
+            while (isThunk<ReturnType<F>>(result)) {
+                result = await result();
+            }
+
+            return result;
+        },
+        {cont},
+    );
+};
+
+
+const factorial = trampoline((n: number, acc: number = 1): ThunkOrValue<number> => {
+    return n
+        // Note: calling factorial.cont instead of factorial directly
+        ? factorial.cont(n - 1, acc * n)
+        : acc;
+});
+
+// factorial(32768)

package/src/data-structures/trie/index.ts

@@ -0,0 +1 @@
+export * from './trie';

package/src/data-structures/trie/trie.ts

@@ -0,0 +1,153 @@
+export class TrieNode {
+    protected _children: Map<string, TrieNode> = new Map<string, TrieNode>();
+
+    get children(): Map<string, TrieNode> {
+        return this._children;
+    }
+
+    set children(v: Map<string, TrieNode>) {
+        this._children = v;
+    }
+
+    protected _isEnd = false;
+
+    get isEnd(): boolean {
+        return this._isEnd;
+    }
+
+    set isEnd(v: boolean) {
+        this._isEnd = v;
+    }
+}
+
+export class Trie {
+    protected _root: TrieNode;
+    get root() {
+        return this._root;
+    }
+
+    set root(v: TrieNode) {
+        this._root = v;
+    }
+
+    constructor() {
+        this._root = new TrieNode();
+    }
+
+    put(input: string): boolean {
+        let cur = this._root;
+        for (const c of input) {
+            let nodeC = cur.children.get(c);
+            if (!nodeC) {
+                nodeC = new TrieNode();
+                cur.children.set(c, nodeC);
+            }
+            cur = nodeC;
+        }
+        cur.isEnd = true;
+        return true;
+    }
+
+
+    has(input: string): boolean {
+        let cur = this._root;
+        for (const c of input) {
+            const nodeC = cur.children.get(c);
+            if (!nodeC) return false;
+            cur = nodeC;
+        }
+        return cur.isEnd;
+    }
+
+    remove(word: string) {
+        let isDeleted = false;
+        const dfs = (cur: TrieNode, i: number): boolean => {
+            const char = word[i];
+            const child = cur.children.get(char);
+            if (child) {
+                if (i === word.length - 1) {
+                    if (child.isEnd) {
+                        if (child.children.size > 0) {
+                            child.isEnd = false;
+                        } else {
+                            cur.children.delete(char);
+                        }
+                        isDeleted = true;
+                        return true;
+                    }
+                    return false;
+                }
+                const res = dfs(child, i + 1);
+                if (res && !cur.isEnd && child.children.size === 0) {
+                    cur.children.delete(char);
+                    return true;
+                }
+                return false;
+            }
+            return false;
+        }
+
+        dfs(this.root, 0);
+        return isDeleted;
+    }
+
+    // --- start additional methods ---
+    /**
+     * Only can present as a prefix, not a word
+     * @param input
+     */
+    isAbsPrefix(input: string): boolean {
+        let cur = this._root;
+        for (const c of input) {
+            const nodeC = cur.children.get(c);
+            if (!nodeC) return false;
+            cur = nodeC;
+        }
+        return !cur.isEnd;
+    }
+
+    /**
+     * Can present as a prefix or word
+     * @param input
+     */
+    isPrefix(input: string): boolean {
+        let cur = this._root;
+        for (const c of input) {
+            const nodeC = cur.children.get(c);
+            if (!nodeC) return false;
+            cur = nodeC;
+        }
+        return true;
+    }
+
+
+    getAll(prefix = ''): string[] {
+        const words: string[] = [];
+
+        function dfs(node: TrieNode, word: string) {
+            for (const char of node.children.keys()) {
+                const charNode = node.children.get(char);
+                if (charNode !== undefined) {
+                    dfs(charNode, word.concat(char));
+                }
+            }
+            if (node.isEnd) {
+                words.push(word);
+            }
+        }
+
+        let startNode = this._root;
+
+        if (prefix) {
+            for (const c of prefix) {
+                const nodeC = startNode.children.get(c);
+                if (nodeC) startNode = nodeC;
+            }
+        }
+
+        dfs(startNode, prefix);
+        return words;
+    }
+
+    // --- end additional methods ---
+}

package/src/index.ts

@@ -0,0 +1 @@
+export * from './data-structures';

package/src/types/index.ts

@@ -0,0 +1 @@
+export * from './utils';