@gabrielrufino/cube 1.0.1 → 1.0.6

package/src/MinHeap/index.ts

@@ -1,91 +0,0 @@
-import IMinHeap from './IMinHeap';
-import IMinHeapOptions from './IMinHeapOptions';
-
-export default class MinHeap<T = number> implements IMinHeap<T> {
-	private _data: T[] = [];
-
-	constructor({lessThanOrEqualTo, inputs = []}: IMinHeapOptions<T> = {inputs: []}) {
-		if (lessThanOrEqualTo) {
-			this._lessThanOrEqualTo = lessThanOrEqualTo;
-		}
-
-		for (const input of inputs) {
-			this.insert(input);
-		}
-	}
-
-	get data(): T[] {
-		return [...this._data];
-	}
-
-	get size(): number {
-		return this.data.length;
-	}
-
-	get isEmpty(): boolean {
-		return this.size === 0;
-	}
-
-	get min(): T | null {
-		return this.data[0] || null;
-	}
-
-	public insert(value: T): T {
-		this._data = [...this.data, value];
-		this._siftUp(this.size - 1);
-		return value;
-	}
-
-	public extract(): T | null {
-		if (!this.isEmpty) {
-			const [min, ...rest] = this.data;
-			this._data = [rest[rest.length - 1], ...rest.slice(0, rest.length - 1)].filter(value => value !== undefined);
-			this._siftDown(0);
-
-			return min;
-		}
-
-		return null;
-	}
-
-	private _lessThanOrEqualTo = (value1: T, value2: T): boolean => value1 <= value2;
-	private _getLeftIndex = (index: number): number => (2 * index) + 1;
-	private _getRightIndex = (index: number): number => (2 * index) + 2;
-	private _getParentIndex = (index: number): number => Math.floor((index - 1) / 2);
-
-	private _siftUp(index: number): void {
-		const parent = this._getParentIndex(index);
-
-		if (index > 0 && this._lessThanOrEqualTo(this.data[index], this.data[parent])) {
-			[this._data[parent], this._data[index]] = [this.data[index], this.data[parent]];
-			this._siftUp(parent);
-		}
-	}
-
-	private _siftDown(index: number): void {
-		const left = this._getLeftIndex(index);
-		const right = this._getRightIndex(index);
-
-		if (left < this.size && this._lessThanOrEqualTo(this.data[left], this.data[index])) {
-			[this._data[left], this._data[index]] = [this.data[index], this.data[left]];
-			this._siftDown(left);
-		}
-
-		if (right < this.size && this._lessThanOrEqualTo(this.data[right], this.data[index])) {
-			[this._data[right], this._data[index]] = [this.data[index], this.data[right]];
-			this._siftDown(right);
-		}
-	}
-
-	private [Symbol.toPrimitive](type: string): string | number | null {
-		if (type === 'string') {
-			return this.data.join(', ');
-		}
-
-		if (type === 'number') {
-			return this.size;
-		}
-
-		return null;
-	}
-}

package/src/Queue/IQueue.ts

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

package/src/Queue/index.spec.ts

@@ -1,92 +0,0 @@
-import {describe, it, expect} from '@jest/globals';
-
-import Queue from './';
-
-describe('Queue', () => {
-	it('Should create an empty queue without problems', () => {
-		const queue = new Queue();
-
-		expect(queue.data).toEqual([]);
-		expect(queue.size).toBe(0);
-	});
-
-	it('Should create a filled queue without problems', () => {
-		const queue = new Queue(1, 2, 3, 4);
-
-		expect(queue.data).toEqual([1, 2, 3, 4]);
-		expect(queue.size).toBe(4);
-	});
-
-	describe('.enqueue()', () => {
-		it('Should enqueue a new element', () => {
-			const queue = new Queue(1, 2, 3);
-			queue.enqueue(4);
-
-			expect(queue.data).toEqual([1, 2, 3, 4]);
-		});
-
-		it('Should return the enqueued element', () => {
-			const queue = new Queue(1, 2, 3);
-			const returned = queue.enqueue(4);
-
-			expect(returned).toBe(4);
-		});
-	});
-
-	describe('.dequeue()', () => {
-		it('Should dequeue the first element', () => {
-			const queue = new Queue(1, 2, 3, 4);
-			queue.dequeue();
-
-			expect(queue.data).toEqual([2, 3, 4]);
-		});
-
-		it('Should return the dequeued element', () => {
-			const queue = new Queue(1, 2, 3, 4);
-			const returned = queue.dequeue();
-
-			expect(returned).toBe(1);
-		});
-	});
-
-	describe('.peek()', () => {
-		it('Should return the first element', () => {
-			const queue = new Queue(1, 2, 3, 4);
-			const returned = queue.peek();
-
-			expect(returned).toEqual(1);
-		});
-
-		it('Should not dequeue the first element', () => {
-			const queue = new Queue(1, 2, 3, 4);
-			queue.peek();
-
-			expect(queue.data).toEqual([1, 2, 3, 4]);
-		});
-	});
-
-	describe('.clear()', () => {
-		it('Should clear a queue', () => {
-			const queue = new Queue(1, 2, 3, 4);
-			queue.clear();
-
-			expect(queue.data).toEqual([]);
-		});
-	});
-
-	describe('Conversion to primitive', () => {
-		it('Should return comma-separated elements in string conversion', () => {
-			const queue = new Queue(1, 2, 3, 4);
-			const string = String(queue);
-
-			expect(string).toBe('[Front] 1, 2, 3, 4');
-		});
-
-		it('Should return the queue size in number conversion', () => {
-			const queue = new Queue(1, 2, 3, 4);
-			const number = Number(queue);
-
-			expect(number).toBe(4);
-		});
-	});
-});

package/src/Queue/index.ts

@@ -1,44 +0,0 @@
-import DataStructure from '../DataStructure';
-import IQueue from './IQueue';
-
-export default class Queue<T = number> extends DataStructure<T> implements IQueue<T> {
-	constructor(...inputs: T[]) {
-		super(inputs);
-	}
-
-	get isEmpty(): boolean {
-		return this.size === 0;
-	}
-
-	public enqueue(element: T): T {
-		this._data = [...this.data, element];
-		return element;
-	}
-
-	public dequeue(): T | undefined {
-		const [element, ...rest] = this.data;
-		this._data = rest;
-		return element;
-	}
-
-	public peek(): T | undefined {
-		const [element] = this.data;
-		return element;
-	}
-
-	public clear(): void {
-		this._data = [];
-	}
-
-	private [Symbol.toPrimitive](type: string): string | number | null {
-		if (type === 'string') {
-			return `[Front] ${this.data.join(', ')}`;
-		}
-
-		if (type === 'number') {
-			return this.size;
-		}
-
-		return null;
-	}
-}

package/src/Set/ISet.ts

@@ -1,17 +0,0 @@
-import Set from './';
-
-interface ISet<T> {
-	get data(): T[];
-	get size(): number;
-	has(_elemet: T): boolean;
-	add(_element: T): T | null;
-	delete(_element: T): T | null;
-	clear(_element: T): T[];
-	union(_set: Set<T>): Set<T>;
-	intersection(_set: Set<T>): Set<T>;
-	difference(_set: Set<T>): Set<T>;
-	isSubsetOf(_set: Set<T>): boolean;
-	contains(_set: Set<T>): boolean;
-}
-
-export default ISet;

package/src/Set/index.spec.ts

@@ -1,246 +0,0 @@
-import {describe, it, expect} from '@jest/globals';
-
-import Set from './';
-
-const cube = {Set};
-
-describe('Set', () => {
-	it('Should create an empty set without problems', () => {
-		const set = new cube.Set();
-
-		expect(set.size).toBe(0);
-		expect(set.data).toEqual([]);
-	});
-
-	it('Should create an empty set without problems', () => {
-		const set = new cube.Set(1, 2, 3, 4);
-
-		expect(set.size).toBe(4);
-		expect(set.data.sort()).toEqual([1, 2, 3, 4].sort());
-	});
-
-	describe('Conversion to primitive', () => {
-		it('Should return comma-separated elements in string conversion', () => {
-			const set = new cube.Set(1, 2, 3, 4);
-			const string = String(set);
-
-			expect(string).toBe('{ 1, 2, 3, 4 }');
-		});
-
-		it('Should return the set size in number conversion', () => {
-			const set = new cube.Set(1, 2, 3, 4);
-			const number = Number(set);
-
-			expect(number).toBe(4);
-		});
-	});
-
-	describe('.has()', () => {
-		it('Should return true when the set has the specified element', () => {
-			const set = new cube.Set(1, 2, 3, 4);
-			const returned = set.has(3);
-
-			expect(returned).toBe(true);
-		});
-
-		it('Should return false when the set has not the specified element', () => {
-			const set = new cube.Set(1, 2, 4);
-			const returned = set.has(3);
-
-			expect(returned).toBe(false);
-		});
-	});
-
-	describe('.add()', () => {
-		it('Should add a new element in the set', () => {
-			const set = new cube.Set(1, 2, 3);
-			set.add(4);
-
-			expect(set.size).toBe(4);
-			expect(set.data.sort()).toEqual([1, 2, 3, 4].sort());
-		});
-
-		it('Should return the inserted element when the element is not in the set', () => {
-			const set = new cube.Set(1, 2, 3);
-			const returned = set.add(4);
-
-			expect(returned).toEqual(4);
-		});
-
-		it('Should return null when the element is in the set', () => {
-			const set = new cube.Set(1, 2, 3, 4);
-			const returned = set.add(4);
-
-			expect(returned).toBeNull();
-		});
-	});
-
-	describe('.delete()', () => {
-		it('Should remove an element in the set', () => {
-			const set = new cube.Set(1, 2, 3, 4);
-			set.delete(3);
-
-			expect(set.size).toBe(3);
-			expect(set.data.sort()).toEqual([1, 2, 4].sort());
-		});
-
-		it('Should not change the set if the element is not in the set', () => {
-			const set = new cube.Set(1, 2, 3, 4);
-			set.delete(5);
-
-			expect(set.size).toBe(4);
-			expect(set.data.sort()).toEqual([1, 2, 3, 4].sort());
-		});
-
-		it('Should return the element if the element was in the set', () => {
-			const set = new cube.Set(1, 2, 3, 4);
-			const returned = set.delete(1);
-
-			expect(returned).toBe(1);
-		});
-
-		it('Should return null if the element was not in the set', () => {
-			const set = new cube.Set(1, 2, 3, 4);
-			const returned = set.delete(5);
-
-			expect(returned).toBeNull();
-		});
-	});
-
-	describe('.clear()', () => {
-		it('Should empty the set', () => {
-			const set = new cube.Set(1, 2, 3, 4);
-			set.clear();
-
-			expect(set.size).toBe(0);
-			expect(set.data).toEqual([]);
-		});
-
-		it('Should return the elements', () => {
-			const set = new cube.Set(1, 2, 3, 4);
-			const returned = set.clear();
-
-			expect(returned.sort()).toEqual([1, 2, 3, 4].sort());
-		});
-	});
-
-	describe('.union()', () => {
-		it('Should return the result of the union between the current set and the received set', () => {
-			const set1 = new cube.Set(1, 2, 3, 4);
-			const set2 = new cube.Set(3, 4, 5, 6);
-			const union = set1.union(set2);
-
-			expect(union.size).toBe(6);
-			expect(union.data.sort()).toEqual([1, 2, 3, 4, 5, 6].sort());
-		});
-	});
-
-	describe('.intersection()', () => {
-		it('Should return the result of the intersection between the current set and the received set', () => {
-			const set1 = new cube.Set(1, 2, 3, 4);
-			const set2 = new cube.Set(3, 4, 5, 6);
-			const intersection = set1.intersection(set2);
-
-			expect(intersection.size).toBe(2);
-			expect(intersection.data.sort()).toEqual([3, 4].sort());
-		});
-	});
-
-	describe('.difference()', () => {
-		it('Should return the result of the difference between the current set and the received set', () => {
-			const set1 = new cube.Set(1, 2, 3, 4);
-			const set2 = new cube.Set(3, 4, 5, 6);
-			const difference = set1.difference(set2);
-
-			expect(difference.size).toBe(2);
-			expect(difference.data.sort()).toEqual([1, 2].sort());
-		});
-	});
-
-	describe('.isSubsetOf()', () => {
-		it('Should return true when the current set is subset of the received set', () => {
-			const set1 = new cube.Set(1, 4);
-			const set2 = new cube.Set(1, 2, 3, 4);
-			const isSubset = set1.isSubsetOf(set2);
-
-			expect(isSubset).toBe(true);
-		});
-
-		it('Should return false whe the current set is not subset of the received set', () => {
-			const set1 = new cube.Set(4, 5);
-			const set2 = new cube.Set(1, 2, 3, 4);
-			const isSubset = set1.isSubsetOf(set2);
-
-			expect(isSubset).toBe(false);
-		});
-	});
-
-	describe('.contains()', () => {
-		it('Should return true when the current set contains the received set', () => {
-			const set1 = new cube.Set(1, 2, 3, 4);
-			const set2 = new cube.Set(1, 4);
-			const contains = set1.contains(set2);
-
-			expect(contains).toBe(true);
-		});
-
-		it('Should return false when the current set does not contains the received set', () => {
-			const set1 = new cube.Set(1, 2, 3, 4);
-			const set2 = new cube.Set(4, 5);
-			const contains = set1.contains(set2);
-
-			expect(contains).toBe(false);
-		});
-	});
-
-	describe('Set.union()', () => {
-		it('Should return an union set between two others', () => {
-			const set1 = new cube.Set(1, 2, 3, 4);
-			const set2 = new cube.Set(3, 4, 5, 6);
-			const union = cube.Set.union(set1, set2);
-
-			expect(union.size).toBe(6);
-			expect(union.data.sort()).toEqual([1, 2, 3, 4, 5, 6].sort());
-		});
-	});
-
-	describe('Set.intersection()', () => {
-		it('Should return an intersection set between two others', () => {
-			const set1 = new cube.Set(1, 2, 3, 4);
-			const set2 = new cube.Set(3, 4, 5, 6);
-			const intersection = cube.Set.intersection(set1, set2);
-
-			expect(intersection.size).toBe(2);
-			expect(intersection.data.sort()).toEqual([3, 4].sort());
-		});
-	});
-
-	describe('Set.difference()', () => {
-		it('Should return an difference set between two others', () => {
-			const set1 = new cube.Set(1, 2, 3, 4);
-			const set2 = new cube.Set(3, 4, 5, 6);
-			const difference = cube.Set.difference(set1, set2);
-
-			expect(difference.size).toBe(2);
-			expect(difference.data.sort()).toEqual([1, 2].sort());
-		});
-	});
-
-	describe('Set.isSubset()', () => {
-		it('Should return true when the first argument is a subset of the second argument', () => {
-			const set1 = new cube.Set(1, 4);
-			const set2 = new cube.Set(1, 2, 3, 4);
-			const isSubset = cube.Set.isSubset(set1, set2);
-
-			expect(isSubset).toBe(true);
-		});
-
-		it('Should return false when the first argument is not a subset of the second argument', () => {
-			const set1 = new cube.Set(4, 5);
-			const set2 = new cube.Set(1, 2, 3, 4);
-			const isSubset = cube.Set.isSubset(set1, set2);
-
-			expect(isSubset).toBe(false);
-		});
-	});
-});

package/src/Set/index.ts

@@ -1,134 +0,0 @@
-import ISet from './ISet';
-
-export default class Set<T = number> implements ISet<T> {
-	private _data: Map<T, T> = new Map<T, T>();
-
-	constructor(...inputs: T[]) {
-		for (const input of inputs) {
-			this.add(input);
-		}
-	}
-
-	public get data(): T[] {
-		return Array.from(this._data.values());
-	}
-
-	public get size(): number {
-		return this._data.size;
-	}
-
-	public has(element: T): boolean {
-		return this._data.has(element);
-	}
-
-	public add(element: T): T | null {
-		if (!this.has(element)) {
-			this._data.set(element, element);
-			return element;
-		}
-
-		return null;
-	}
-
-	public delete(element: T): T | null {
-		if (this.has(element)) {
-			this._data.delete(element);
-			return element;
-		}
-
-		return null;
-	}
-
-	public clear(): T[] {
-		const elements = [...this.data];
-		this._data.clear();
-		return elements;
-	}
-
-	public union(set: Set<T>): Set<T> {
-		return Set.union(this, set);
-	}
-
-	public intersection(set: Set<T>): Set<T> {
-		return Set.intersection(this, set);
-	}
-
-	public difference(set: Set<T>): Set<T> {
-		return Set.difference(this, set);
-	}
-
-	public isSubsetOf(set: Set<T>): boolean {
-		return Set.isSubset(this, set);
-	}
-
-	public contains(set: Set<T>): boolean {
-		return Set.isSubset(set, this);
-	}
-
-	static union<T>(set1: Set<T>, set2: Set<T>): Set<T> {
-		const union = new Set<T>();
-
-		for (const element of [...set1.data, ...set2.data]) {
-			union.add(element);
-		}
-
-		return union;
-	}
-
-	static intersection<T>(set1: Set<T>, set2: Set<T>): Set<T> {
-		let biggestSet: Set<T>;
-		let smallestSet: Set<T>;
-
-		if (set1.size >= set2.size) {
-			biggestSet = set1;
-			smallestSet = set2;
-		} else {
-			biggestSet = set2;
-			smallestSet = set1;
-		}
-
-		const intersection = new Set<T>();
-
-		for (const element of smallestSet.data) {
-			if (biggestSet.has(element)) {
-				intersection.add(element);
-			}
-		}
-
-		return intersection;
-	}
-
-	static difference<T>(set1: Set<T>, set2: Set<T>): Set<T> {
-		const difference = new Set<T>();
-
-		for (const element of set1.data) {
-			if (!set2.has(element)) {
-				difference.add(element);
-			}
-		}
-
-		return difference;
-	}
-
-	static isSubset<T>(set1: Set<T>, set2: Set<T>): boolean {
-		if (set1.size > set2.size) {
-			return false;
-		}
-
-		return set1
-			.data
-			.every(element => set2.has(element));
-	}
-
-	private [Symbol.toPrimitive](type: string): string | number | null {
-		if (type === 'string') {
-			return `{ ${this.data.join(', ')} }`;
-		}
-
-		if (type === 'number') {
-			return this.size;
-		}
-
-		return null;
-	}
-}

package/src/Stack/IStack.ts

@@ -1,9 +0,0 @@
-interface IStack<T> {
-	push(_element: T): T;
-	pop(): T | undefined;
-	peek(): T | undefined;
-	clear(): void;
-	get isEmpty(): boolean;
-}
-
-export default IStack;