@gabrielrufino/cube 1.0.1

package/build/HashTableSeparateChaining/index.js

@@ -0,0 +1,104 @@
+"use strict";
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+var HashTableSeparateChainingElement_1 = __importDefault(require("./HashTableSeparateChainingElement"));
+var LinkedList_1 = __importDefault(require("../LinkedList"));
+var HashTableSeparateChaining = /** @class */ (function () {
+    function HashTableSeparateChaining(inputs, _a) {
+        if (inputs === void 0) { inputs = {}; }
+        var _b = _a === void 0 ? { maxSize: 100 } : _a, maxSize = _b.maxSize;
+        this._maxSize = maxSize;
+        this._data = new Array(this._maxSize);
+        for (var _i = 0, _c = Object.entries(inputs); _i < _c.length; _i++) {
+            var _d = _c[_i], key = _d[0], value = _d[1];
+            this.put(key, value);
+        }
+    }
+    Object.defineProperty(HashTableSeparateChaining.prototype, "data", {
+        get: function () {
+            return this._data
+                .map(function (value, key) { return ({ key: key, value: value }); })
+                .reduce(function (accumulator, current) {
+                var _a;
+                return (__assign(__assign({}, accumulator), (_a = {}, _a[current.key] = current.value, _a)));
+            }, {});
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(HashTableSeparateChaining.prototype, "size", {
+        get: function () {
+            return Reflect.ownKeys(this.data).length;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    HashTableSeparateChaining.prototype.put = function (key, value) {
+        var linkedList = this._getLinkedListByKey(key);
+        var element = new HashTableSeparateChainingElement_1.default(key, value);
+        if (linkedList) {
+            linkedList.push(element);
+        }
+        else {
+            var position = this._hashCode(key);
+            this._data[position] = new LinkedList_1.default(element);
+        }
+        return value;
+    };
+    HashTableSeparateChaining.prototype.get = function (key) {
+        var linkedList = this._getLinkedListByKey(key);
+        if (linkedList) {
+            var element = linkedList.data.find(function (element) { return element.value.key === key; });
+            return (element === null || element === void 0 ? void 0 : element.value) || null;
+        }
+        return null;
+    };
+    HashTableSeparateChaining.prototype.remove = function (key) {
+        var linkedList = this._getLinkedListByKey(key);
+        if (linkedList) {
+            var index = linkedList.data.findIndex(function (element) { return element.value.key === key; });
+            var element = linkedList.removeFromPosition(index);
+            if (linkedList.isEmpty) {
+                var position = this._hashCode(key);
+                Reflect.deleteProperty(this._data, position);
+            }
+            return element || null;
+        }
+        return null;
+    };
+    HashTableSeparateChaining.prototype._getLinkedListByKey = function (key) {
+        var position = this._hashCode(key);
+        return Reflect.get(this.data, position) || null;
+    };
+    HashTableSeparateChaining.prototype._hashCode = function (key) {
+        var code = key
+            .split('')
+            .map(function (character) { return character.charCodeAt(0); })
+            .reduce(function (previous, current) { return previous + current; }, 0);
+        return code % this._maxSize;
+    };
+    HashTableSeparateChaining.prototype[Symbol.toPrimitive] = function (type) {
+        if (type === 'string') {
+            return "[ ".concat(Object.values(this.data).map(String).join(', '), " ]");
+        }
+        if (type === 'number') {
+            return this.size;
+        }
+        return null;
+    };
+    return HashTableSeparateChaining;
+}());
+exports.default = HashTableSeparateChaining;

package/build/LinkedList/ILinkedList.d.ts

@@ -0,0 +1,13 @@
+import ILinkedListItem from './ILinkedListItem';
+interface ILinkedList<T> {
+    get data(): ILinkedListItem<T>[];
+    get size(): number;
+    get isEmpty(): boolean;
+    push(_element: T): T;
+    getFromPosition(_position: number): ILinkedListItem<T> | undefined;
+    positionOf(_element: T): number | undefined;
+    insertInPosition(_element: T, _position: number): T | undefined;
+    remove(_element: T): T | undefined;
+    removeFromPosition(_position: number): T | undefined;
+}
+export default ILinkedList;

package/build/LinkedList/ILinkedList.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/build/LinkedList/ILinkedListItem.d.ts

@@ -0,0 +1,5 @@
+interface ILinkedListItem<T> {
+    value: T;
+    next: T | null;
+}
+export default ILinkedListItem;

package/build/LinkedList/ILinkedListItem.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/build/LinkedList/Node.d.ts

@@ -0,0 +1,5 @@
+export default class Node<T> {
+    value: T;
+    next: Node<T> | null;
+    constructor(value: T);
+}

package/build/LinkedList/Node.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var Node = /** @class */ (function () {
+    function Node(value) {
+        this.next = null;
+        this.value = value;
+    }
+    return Node;
+}());
+exports.default = Node;

package/build/LinkedList/index.d.ts

@@ -0,0 +1,24 @@
+import ILinkedList from './ILinkedList';
+export default class LinkedList<T = number> implements ILinkedList<T> {
+    private readonly _FIRST_POSITION;
+    private _head;
+    private _size;
+    constructor(...inputs: T[]);
+    get data(): {
+        value: T;
+        next: T | null;
+    }[];
+    get size(): number;
+    get isEmpty(): boolean;
+    positionOf(element: T): number | undefined;
+    push(element: T): T;
+    remove(element: T): T | undefined;
+    insertInPosition(element: T, position: number): T | undefined;
+    getFromPosition(position: number): {
+        value: T;
+        next: T | null;
+    } | undefined;
+    removeFromPosition(position: number): T | undefined;
+    private getNodeFromPosition;
+    private [Symbol.toPrimitive];
+}

package/build/LinkedList/index.js

@@ -0,0 +1,169 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+var Node_1 = __importDefault(require("./Node"));
+var LinkedList = /** @class */ (function () {
+    function LinkedList() {
+        var inputs = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            inputs[_i] = arguments[_i];
+        }
+        this._FIRST_POSITION = 0;
+        this._head = null;
+        this._size = 0;
+        if (inputs.length) {
+            var nodes = inputs.map(function (input) { return new Node_1.default(input); });
+            for (var i = 0; i < inputs.length - 1; i++) {
+                nodes[i].next = nodes[i + 1];
+            }
+            this._head = nodes[0];
+            this._size = nodes.length;
+        }
+    }
+    Object.defineProperty(LinkedList.prototype, "data", {
+        get: function () {
+            var _a;
+            var data = [];
+            var current = this._head;
+            while (current) {
+                data.push({
+                    value: current.value,
+                    next: ((_a = current.next) === null || _a === void 0 ? void 0 : _a.value) || null,
+                });
+                current = current.next;
+            }
+            return data;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(LinkedList.prototype, "size", {
+        get: function () {
+            return this._size;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(LinkedList.prototype, "isEmpty", {
+        get: function () {
+            return this.size === 0;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    LinkedList.prototype.positionOf = function (element) {
+        var current = this._head;
+        var position = 0;
+        while (current && current.value !== element) {
+            current = current === null || current === void 0 ? void 0 : current.next;
+            position += 1;
+        }
+        if (current) {
+            return position;
+        }
+    };
+    LinkedList.prototype.push = function (element) {
+        if (this._head) {
+            var current = this._head;
+            while (current.next) {
+                current = current.next;
+            }
+            current.next = new Node_1.default(element);
+        }
+        else {
+            this._head = new Node_1.default(element);
+        }
+        this._size += 1;
+        return element;
+    };
+    LinkedList.prototype.remove = function (element) {
+        var position = this.positionOf(element);
+        if (position) {
+            return this.removeFromPosition(position);
+        }
+    };
+    LinkedList.prototype.insertInPosition = function (element, position) {
+        if (position < this._FIRST_POSITION || position > this.size) {
+            return undefined;
+        }
+        var node = new Node_1.default(element);
+        if (position === this._FIRST_POSITION) {
+            node.next = this._head;
+            this._head = node;
+        }
+        else {
+            var before = this.getNodeFromPosition(position - 1);
+            var after = (before && before.next) || null;
+            if (before) {
+                before.next = node;
+            }
+            node.next = after;
+        }
+        this._size += 1;
+        return element;
+    };
+    LinkedList.prototype.getFromPosition = function (position) {
+        var _a;
+        if (position < this._FIRST_POSITION || position > this.size - 1) {
+            return undefined;
+        }
+        var node = this._head;
+        for (var i = 0; i < position; i++) {
+            node = (node === null || node === void 0 ? void 0 : node.next) || null;
+        }
+        if (node === null || node === void 0 ? void 0 : node.value) {
+            return {
+                value: node.value,
+                next: ((_a = node.next) === null || _a === void 0 ? void 0 : _a.value) || null,
+            };
+        }
+        return undefined;
+    };
+    LinkedList.prototype.removeFromPosition = function (position) {
+        if (position < this._FIRST_POSITION || position > (this.size - 1)) {
+            return undefined;
+        }
+        var current = this._head;
+        if (position === this._FIRST_POSITION) {
+            this._head = (current === null || current === void 0 ? void 0 : current.next) || null;
+        }
+        else {
+            var previous = void 0;
+            for (var i = 0; i < position; i++) {
+                previous = current;
+                current = (current === null || current === void 0 ? void 0 : current.next) || null;
+            }
+            if (previous) {
+                previous.next = (current === null || current === void 0 ? void 0 : current.next) || null;
+            }
+        }
+        this._size -= 1;
+        return current === null || current === void 0 ? void 0 : current.value;
+    };
+    LinkedList.prototype.getNodeFromPosition = function (position) {
+        if (position < this._FIRST_POSITION || position > this.size - 1) {
+            return undefined;
+        }
+        var node = this._head;
+        for (var i = 0; i < position; i++) {
+            node = (node === null || node === void 0 ? void 0 : node.next) || null;
+        }
+        return node || undefined;
+    };
+    LinkedList.prototype[Symbol.toPrimitive] = function (type) {
+        if (type === 'string') {
+            return "[Head] ".concat(this.data.map(function (_a) {
+                var value = _a.value;
+                return value;
+            }).join(' => '));
+        }
+        if (type === 'number') {
+            return this.size;
+        }
+        return null;
+    };
+    return LinkedList;
+}());
+exports.default = LinkedList;

package/build/List/index.d.ts

@@ -0,0 +1 @@
+export { default } from '../Array';

package/build/List/index.js

@@ -0,0 +1,8 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = void 0;
+var Array_1 = require("../Array");
+Object.defineProperty(exports, "default", { enumerable: true, get: function () { return __importDefault(Array_1).default; } });

package/build/MaxHeap/IMaxHeap.d.ts

@@ -0,0 +1,9 @@
+interface IMaxHeap<T> {
+    get data(): T[];
+    get size(): number;
+    get isEmpty(): boolean;
+    get max(): T | null;
+    insert(_value: T): T;
+    extract(): T | null;
+}
+export default IMaxHeap;

package/build/MaxHeap/IMaxHeap.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/build/MaxHeap/IMaxHeapOptions.d.ts

@@ -0,0 +1,5 @@
+interface IMaxHeapOptions<T> {
+    greaterThanOrEqualTo?: (_value1: T, _value2: T) => boolean;
+    inputs?: T[];
+}
+export default IMaxHeapOptions;

package/build/MaxHeap/IMaxHeapOptions.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/build/MaxHeap/index.d.ts

@@ -0,0 +1,19 @@
+import IMaxHeap from './IMaxHeap';
+import IMaxHeapOptions from './IMaxHeapOptions';
+export default class MaxHeap<T = number> implements IMaxHeap<T> {
+    private _data;
+    constructor({ greaterThanOrEqualTo, inputs }?: IMaxHeapOptions<T>);
+    get data(): T[];
+    get size(): number;
+    get isEmpty(): boolean;
+    get max(): T | null;
+    insert(value: T): T;
+    extract(): T | null;
+    private _greaterThanOrEqualTo;
+    private _getLeftIndex;
+    private _getRightIndex;
+    private _getParentIndex;
+    private _siftUp;
+    private _siftDown;
+    private [Symbol.toPrimitive];
+}

package/build/MaxHeap/index.js

@@ -0,0 +1,102 @@
+"use strict";
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+var MaxHeap = /** @class */ (function () {
+    function MaxHeap(_a) {
+        var _b = _a === void 0 ? { inputs: [] } : _a, greaterThanOrEqualTo = _b.greaterThanOrEqualTo, _c = _b.inputs, inputs = _c === void 0 ? [] : _c;
+        this._data = [];
+        this._greaterThanOrEqualTo = function (value1, value2) { return value1 >= value2; };
+        this._getLeftIndex = function (index) { return (2 * index) + 1; };
+        this._getRightIndex = function (index) { return (2 * index) + 2; };
+        this._getParentIndex = function (index) { return Math.floor((index - 1) / 2); };
+        if (greaterThanOrEqualTo) {
+            this._greaterThanOrEqualTo = greaterThanOrEqualTo;
+        }
+        for (var _i = 0, inputs_1 = inputs; _i < inputs_1.length; _i++) {
+            var input = inputs_1[_i];
+            this.insert(input);
+        }
+    }
+    Object.defineProperty(MaxHeap.prototype, "data", {
+        get: function () {
+            return __spreadArray([], this._data, true);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(MaxHeap.prototype, "size", {
+        get: function () {
+            return this.data.length;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(MaxHeap.prototype, "isEmpty", {
+        get: function () {
+            return this.size === 0;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(MaxHeap.prototype, "max", {
+        get: function () {
+            return this.data[0] || null;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    MaxHeap.prototype.insert = function (value) {
+        this._data = __spreadArray(__spreadArray([], this.data, true), [value], false);
+        this._siftUp(this.size - 1);
+        return value;
+    };
+    MaxHeap.prototype.extract = function () {
+        if (!this.isEmpty) {
+            var _a = this.data, min = _a[0], rest = _a.slice(1);
+            this._data = __spreadArray([rest[rest.length - 1]], rest.slice(0, rest.length - 1), true).filter(function (value) { return value !== undefined; });
+            this._siftDown(0);
+            return min;
+        }
+        return null;
+    };
+    MaxHeap.prototype._siftUp = function (index) {
+        var _a;
+        var parent = this._getParentIndex(index);
+        if (index > 0 && this._greaterThanOrEqualTo(this.data[index], this.data[parent])) {
+            _a = [this.data[index], this.data[parent]], this._data[parent] = _a[0], this._data[index] = _a[1];
+            this._siftUp(parent);
+        }
+    };
+    MaxHeap.prototype._siftDown = function (index) {
+        var _a, _b;
+        var left = this._getLeftIndex(index);
+        var right = this._getRightIndex(index);
+        if (left < this.size && this._greaterThanOrEqualTo(this.data[left], this.data[index])) {
+            _a = [this.data[index], this.data[left]], this._data[left] = _a[0], this._data[index] = _a[1];
+            this._siftDown(left);
+        }
+        if (right < this.size && this._greaterThanOrEqualTo(this.data[right], this.data[index])) {
+            _b = [this.data[index], this.data[right]], this._data[right] = _b[0], this._data[index] = _b[1];
+            this._siftDown(right);
+        }
+    };
+    MaxHeap.prototype[Symbol.toPrimitive] = function (type) {
+        if (type === 'string') {
+            return this.data.join(', ');
+        }
+        if (type === 'number') {
+            return this.size;
+        }
+        return null;
+    };
+    return MaxHeap;
+}());
+exports.default = MaxHeap;

package/build/MinHeap/IMinHeap.d.ts

@@ -0,0 +1,9 @@
+interface IMinHeap<T> {
+    get data(): T[];
+    get size(): number;
+    get isEmpty(): boolean;
+    get min(): T | null;
+    insert(_value: T): T;
+    extract(): T | null;
+}
+export default IMinHeap;

package/build/MinHeap/IMinHeap.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/build/MinHeap/IMinHeapOptions.d.ts

@@ -0,0 +1,5 @@
+interface IMinHeapOptions<T> {
+    lessThanOrEqualTo?: (_value1: T, _value2: T) => boolean;
+    inputs?: T[];
+}
+export default IMinHeapOptions;

package/build/MinHeap/IMinHeapOptions.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/build/MinHeap/index.d.ts

@@ -0,0 +1,19 @@
+import IMinHeap from './IMinHeap';
+import IMinHeapOptions from './IMinHeapOptions';
+export default class MinHeap<T = number> implements IMinHeap<T> {
+    private _data;
+    constructor({ lessThanOrEqualTo, inputs }?: IMinHeapOptions<T>);
+    get data(): T[];
+    get size(): number;
+    get isEmpty(): boolean;
+    get min(): T | null;
+    insert(value: T): T;
+    extract(): T | null;
+    private _lessThanOrEqualTo;
+    private _getLeftIndex;
+    private _getRightIndex;
+    private _getParentIndex;
+    private _siftUp;
+    private _siftDown;
+    private [Symbol.toPrimitive];
+}

package/build/MinHeap/index.js

@@ -0,0 +1,102 @@
+"use strict";
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+var MinHeap = /** @class */ (function () {
+    function MinHeap(_a) {
+        var _b = _a === void 0 ? { inputs: [] } : _a, lessThanOrEqualTo = _b.lessThanOrEqualTo, _c = _b.inputs, inputs = _c === void 0 ? [] : _c;
+        this._data = [];
+        this._lessThanOrEqualTo = function (value1, value2) { return value1 <= value2; };
+        this._getLeftIndex = function (index) { return (2 * index) + 1; };
+        this._getRightIndex = function (index) { return (2 * index) + 2; };
+        this._getParentIndex = function (index) { return Math.floor((index - 1) / 2); };
+        if (lessThanOrEqualTo) {
+            this._lessThanOrEqualTo = lessThanOrEqualTo;
+        }
+        for (var _i = 0, inputs_1 = inputs; _i < inputs_1.length; _i++) {
+            var input = inputs_1[_i];
+            this.insert(input);
+        }
+    }
+    Object.defineProperty(MinHeap.prototype, "data", {
+        get: function () {
+            return __spreadArray([], this._data, true);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(MinHeap.prototype, "size", {
+        get: function () {
+            return this.data.length;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(MinHeap.prototype, "isEmpty", {
+        get: function () {
+            return this.size === 0;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(MinHeap.prototype, "min", {
+        get: function () {
+            return this.data[0] || null;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    MinHeap.prototype.insert = function (value) {
+        this._data = __spreadArray(__spreadArray([], this.data, true), [value], false);
+        this._siftUp(this.size - 1);
+        return value;
+    };
+    MinHeap.prototype.extract = function () {
+        if (!this.isEmpty) {
+            var _a = this.data, min = _a[0], rest = _a.slice(1);
+            this._data = __spreadArray([rest[rest.length - 1]], rest.slice(0, rest.length - 1), true).filter(function (value) { return value !== undefined; });
+            this._siftDown(0);
+            return min;
+        }
+        return null;
+    };
+    MinHeap.prototype._siftUp = function (index) {
+        var _a;
+        var parent = this._getParentIndex(index);
+        if (index > 0 && this._lessThanOrEqualTo(this.data[index], this.data[parent])) {
+            _a = [this.data[index], this.data[parent]], this._data[parent] = _a[0], this._data[index] = _a[1];
+            this._siftUp(parent);
+        }
+    };
+    MinHeap.prototype._siftDown = function (index) {
+        var _a, _b;
+        var left = this._getLeftIndex(index);
+        var right = this._getRightIndex(index);
+        if (left < this.size && this._lessThanOrEqualTo(this.data[left], this.data[index])) {
+            _a = [this.data[index], this.data[left]], this._data[left] = _a[0], this._data[index] = _a[1];
+            this._siftDown(left);
+        }
+        if (right < this.size && this._lessThanOrEqualTo(this.data[right], this.data[index])) {
+            _b = [this.data[index], this.data[right]], this._data[right] = _b[0], this._data[index] = _b[1];
+            this._siftDown(right);
+        }
+    };
+    MinHeap.prototype[Symbol.toPrimitive] = function (type) {
+        if (type === 'string') {
+            return this.data.join(', ');
+        }
+        if (type === 'number') {
+            return this.size;
+        }
+        return null;
+    };
+    return MinHeap;
+}());
+exports.default = MinHeap;

package/build/Queue/IQueue.d.ts

@@ -0,0 +1,8 @@
+interface IQueue<T> {
+    enqueue(_element: T): T;
+    dequeue(): T | undefined;
+    peek(): T | undefined;
+    clear(): void;
+    get isEmpty(): boolean;
+}
+export default IQueue;

package/build/Queue/IQueue.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });