@gabrielrufino/cube 1.0.1 → 1.0.6

package/src/LinkedList/index.ts

@@ -1,185 +0,0 @@
-import ILinkedList from './ILinkedList';
-import Node from './Node';
-
-export default class LinkedList<T = number> implements ILinkedList<T> {
-	private readonly _FIRST_POSITION = 0;
-	private _head: Node<T> | null = null;
-	private _size: number = 0;
-
-	constructor(...inputs: T[]) {
-		if (inputs.length) {
-			const nodes = inputs.map(input => new Node<T>(input));
-
-			for (let i = 0; i < inputs.length - 1; i++) {
-				nodes[i].next = nodes[i + 1];
-			}
-
-			this._head = nodes[0];
-			this._size = nodes.length;
-		}
-	}
-
-	public get data() {
-		const data = [];
-
-		let current = this._head;
-
-		while (current) {
-			data.push({
-				value: current.value,
-				next: current.next?.value || null,
-			});
-
-			current = current.next;
-		}
-
-		return data;
-	}
-
-	public get size() {
-		return this._size;
-	}
-
-	public get isEmpty() {
-		return this.size === 0;
-	}
-
-	public positionOf(element: T): number | undefined {
-		let current = this._head;
-		let position = 0;
-
-		while (current && current.value !== element) {
-			current = current?.next;
-			position += 1;
-		}
-
-		if (current) {
-			return position;
-		}
-	}
-
-	public push(element: T): T {
-		if (this._head) {
-			let current: Node<T> = this._head;
-
-			while (current.next) {
-				current = current.next;
-			}
-
-			current.next = new Node<T>(element);
-		} else {
-			this._head = new Node<T>(element);
-		}
-
-		this._size += 1;
-
-		return element;
-	}
-
-	public remove(element: T): T | undefined {
-		const position = this.positionOf(element);
-
-		if (position) {
-			return this.removeFromPosition(position);
-		}
-	}
-
-	public insertInPosition(element: T, position: number): T | undefined {
-		if (position < this._FIRST_POSITION || position > this.size) {
-			return undefined;
-		}
-
-		const node = new Node<T>(element);
-
-		if (position === this._FIRST_POSITION) {
-			node.next = this._head;
-			this._head = node;
-		} else {
-			const before = this.getNodeFromPosition(position - 1);
-			const after = (before && before.next) || null;
-
-			if (before) {
-				before.next = node;
-			}
-
-			node.next = after;
-		}
-
-		this._size += 1;
-
-		return element;
-	}
-
-	public getFromPosition(position: number) {
-		if (position < this._FIRST_POSITION || position > this.size - 1) {
-			return undefined;
-		}
-
-		let node = this._head;
-
-		for (let i = 0; i < position; i++) {
-			node = node?.next || null;
-		}
-
-		if (node?.value) {
-			return {
-				value: node.value,
-				next: node.next?.value || null,
-			};
-		}
-
-		return undefined;
-	}
-
-	public removeFromPosition(position: number): T | undefined {
-		if (position < this._FIRST_POSITION || position > (this.size - 1)) {
-			return undefined;
-		}
-
-		let current: Node<T> | null = this._head;
-
-		if (position === this._FIRST_POSITION) {
-			this._head = current?.next || null;
-		} else {
-			let previous: Node<T> | null | undefined;
-
-			for (let i = 0; i < position; i++) {
-				previous = current;
-				current = current?.next || null;
-			}
-
-			if (previous) {
-				previous.next = current?.next || null;
-			}
-		}
-
-		this._size -= 1;
-		return current?.value;
-	}
-
-	private getNodeFromPosition(position: number): Node<T> | undefined {
-		if (position < this._FIRST_POSITION || position > this.size - 1) {
-			return undefined;
-		}
-
-		let node = this._head;
-
-		for (let i = 0; i < position; i++) {
-			node = node?.next || null;
-		}
-
-		return node || undefined;
-	}
-
-	private [Symbol.toPrimitive](type: string): string | number | null {
-		if (type === 'string') {
-			return `[Head] ${this.data.map(({value}) => value).join(' => ')}`;
-		}
-
-		if (type === 'number') {
-			return this.size;
-		}
-
-		return null;
-	}
-}

package/src/List/index.ts

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

package/src/MaxHeap/IMaxHeap.ts

@@ -1,10 +0,0 @@
-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/src/MaxHeap/IMaxHeapOptions.ts

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

package/src/MaxHeap/index.spec.ts

@@ -1,161 +0,0 @@
-import {describe, it, expect} from '@jest/globals';
-import faker from 'faker';
-
-import MaxHeap from './';
-
-describe('MaxHeap', () => {
-	it('Should create an empty max heap without problems', () => {
-		const maxHeap = new MaxHeap();
-
-		expect(maxHeap.data).toEqual([]);
-		expect(maxHeap.size).toBe(0);
-	});
-
-	it('Should create a filled max heap without problems', () => {
-		const maxHeap = new MaxHeap({
-			inputs: [5, 2, 1, 9],
-		});
-
-		expect(maxHeap.data).toEqual([9, 5, 1, 2]);
-		expect(maxHeap.size).toBe(4);
-	});
-
-	describe('.isEmpty', () => {
-		it('Should be true when the heap has no values', () => {
-			const maxHeap = new MaxHeap();
-
-			expect(maxHeap.isEmpty).toBe(true);
-		});
-
-		it('Should be false when the heap has at least one value', () => {
-			const maxHeap = new MaxHeap({
-				inputs: [faker.datatype.number()],
-			});
-
-			expect(maxHeap.isEmpty).toBe(false);
-		});
-	});
-
-	describe('.max', () => {
-		it('Should be the min value when the heap is not empty', () => {
-			const inputs = new Array(10).fill(undefined).map(faker.datatype.number);
-			const maxHeap = new MaxHeap({
-				inputs,
-			});
-
-			expect(maxHeap.max).toBe(Math.max(...inputs));
-		});
-
-		it('Should be null when the heap is empty', () => {
-			const maxHeap = new MaxHeap();
-
-			expect(maxHeap.max).toBeNull();
-		});
-	});
-
-	describe('.insert()', () => {
-		it('Should insert new values in the heap', () => {
-			const maxHeap = new MaxHeap();
-
-			maxHeap.insert(5);
-			expect(maxHeap.data).toEqual([5]);
-			expect(maxHeap.size).toBe(1);
-
-			maxHeap.insert(2);
-			expect(maxHeap.data).toEqual([5, 2]);
-			expect(maxHeap.size).toBe(2);
-
-			maxHeap.insert(1);
-			expect(maxHeap.data).toEqual([5, 2, 1]);
-			expect(maxHeap.size).toBe(3);
-
-			maxHeap.insert(9);
-			expect(maxHeap.data).toEqual([9, 5, 1, 2]);
-			expect(maxHeap.size).toBe(4);
-		});
-
-		it('Should return the inserted value', () => {
-			const maxHeap = new MaxHeap();
-			const value = faker.datatype.number();
-			const returned = maxHeap.insert(value);
-
-			expect(returned).toBe(value);
-		});
-	});
-
-	describe('.extract()', () => {
-		it('Should extract the max value of the heap and adjust the heap after this', () => {
-			const maxHeap = new MaxHeap({
-				inputs: [9, 8, 7, 6, 5, 4, 3, 2, 1],
-			});
-			maxHeap.extract();
-
-			expect(maxHeap.data).toEqual([8, 6, 7, 2, 5, 4, 3, 1]);
-			expect(maxHeap.size).toBe(8);
-		});
-
-		it('Should return the extracted value', () => {
-			const inputs = new Array(10).fill(undefined).map(faker.datatype.number);
-			const maxHeap = new MaxHeap({inputs});
-			const returned = maxHeap.extract();
-
-			expect(returned).toBe(Math.max(...inputs));
-		});
-
-		it('Should change nothing if the heap is empty', () => {
-			const maxHeap = new MaxHeap();
-			maxHeap.extract();
-
-			expect(maxHeap.data).toEqual([]);
-			expect(maxHeap.size).toBe(0);
-		});
-	});
-
-	describe('Heap Sort', () => {
-		it('Should sort an array in DESC order', () => {
-			const maxHeap = new MaxHeap({
-				inputs: [
-					7,
-					1,
-					10,
-					4,
-					8,
-					6,
-					2,
-					3,
-					5,
-					9,
-				],
-			});
-
-			const {size} = maxHeap;
-			const result = [];
-
-			for (let i = 1; i <= size; i++) {
-				result.push(maxHeap.extract());
-			}
-
-			expect(result).toEqual([10, 9, 8, 7, 6, 5, 4, 3, 2, 1]);
-		});
-	});
-
-	describe('Conversion to primitive', () => {
-		it('Should return separated by comma values in string conversion', () => {
-			const maxHeap = new MaxHeap({
-				inputs: [1, 2, 3, 4, 5],
-			});
-			const string = String(maxHeap);
-
-			expect(string).toBe('5, 4, 2, 1, 3');
-		});
-
-		it('Should return the size in number conversion', () => {
-			const maxHeap = new MaxHeap({
-				inputs: [1, 2, 3, 4, 5],
-			});
-			const number = Number(maxHeap);
-
-			expect(number).toBe(5);
-		});
-	});
-});

package/src/MaxHeap/index.ts

@@ -1,91 +0,0 @@
-import IMaxHeap from './IMaxHeap';
-import IMaxHeapOptions from './IMaxHeapOptions';
-
-export default class MaxHeap<T = number> implements IMaxHeap<T> {
-	private _data: T[] = [];
-
-	constructor({greaterThanOrEqualTo, inputs = []}: IMaxHeapOptions<T> = {inputs: []}) {
-		if (greaterThanOrEqualTo) {
-			this._greaterThanOrEqualTo = greaterThanOrEqualTo;
-		}
-
-		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 max(): 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 _greaterThanOrEqualTo = (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._greaterThanOrEqualTo(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._greaterThanOrEqualTo(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._greaterThanOrEqualTo(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/MinHeap/IMinHeap.ts

@@ -1,10 +0,0 @@
-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/src/MinHeap/IMinHeapOptions.ts

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

package/src/MinHeap/index.spec.ts

@@ -1,161 +0,0 @@
-import {describe, it, expect} from '@jest/globals';
-import faker from 'faker';
-
-import MinHeap from './';
-
-describe('MinHeap', () => {
-	it('Should create an empty min heap without problems', () => {
-		const minHeap = new MinHeap();
-
-		expect(minHeap.data).toEqual([]);
-		expect(minHeap.size).toBe(0);
-	});
-
-	it('Should create a filled min heap without problems', () => {
-		const minHeap = new MinHeap({
-			inputs: [5, 2, 1, 9],
-		});
-
-		expect(minHeap.data).toEqual([1, 5, 2, 9]);
-		expect(minHeap.size).toBe(4);
-	});
-
-	describe('.isEmpty', () => {
-		it('Should be true when the heap has no values', () => {
-			const minHeap = new MinHeap();
-
-			expect(minHeap.isEmpty).toBe(true);
-		});
-
-		it('Should be false when the heap has at least one value', () => {
-			const minHeap = new MinHeap({
-				inputs: [faker.datatype.number()],
-			});
-
-			expect(minHeap.isEmpty).toBe(false);
-		});
-	});
-
-	describe('.min', () => {
-		it('Should be the min value when the heap is not empty', () => {
-			const inputs = new Array(10).fill(undefined).map(faker.datatype.number);
-			const minHeap = new MinHeap({
-				inputs,
-			});
-
-			expect(minHeap.min).toBe(Math.min(...inputs));
-		});
-
-		it('Should be null when the heap is empty', () => {
-			const minHeap = new MinHeap();
-
-			expect(minHeap.min).toBeNull();
-		});
-	});
-
-	describe('.insert()', () => {
-		it('Should insert new values in the heap', () => {
-			const minHeap = new MinHeap();
-
-			minHeap.insert(5);
-			expect(minHeap.data).toEqual([5]);
-			expect(minHeap.size).toBe(1);
-
-			minHeap.insert(2);
-			expect(minHeap.data).toEqual([2, 5]);
-			expect(minHeap.size).toBe(2);
-
-			minHeap.insert(1);
-			expect(minHeap.data).toEqual([1, 5, 2]);
-			expect(minHeap.size).toBe(3);
-
-			minHeap.insert(9);
-			expect(minHeap.data).toEqual([1, 5, 2, 9]);
-			expect(minHeap.size).toBe(4);
-		});
-
-		it('Should return the inserted value', () => {
-			const minHeap = new MinHeap();
-			const value = faker.datatype.number();
-			const returned = minHeap.insert(value);
-
-			expect(returned).toBe(value);
-		});
-	});
-
-	describe('.extract()', () => {
-		it('Should extract the min value of the heap and adjust the heap after this', () => {
-			const minHeap = new MinHeap({
-				inputs: [1, 2, 3, 4, 5, 6, 7, 8, 9],
-			});
-			minHeap.extract();
-
-			expect(minHeap.data).toEqual([2, 4, 3, 8, 5, 6, 7, 9]);
-			expect(minHeap.size).toBe(8);
-		});
-
-		it('Should return the extracted value', () => {
-			const inputs = new Array(10).fill(undefined).map(faker.datatype.number);
-			const minHeap = new MinHeap({inputs});
-			const returned = minHeap.extract();
-
-			expect(returned).toBe(Math.min(...inputs));
-		});
-
-		it('Should change nothing if the heap is empty', () => {
-			const minHeap = new MinHeap();
-			minHeap.extract();
-
-			expect(minHeap.data).toEqual([]);
-			expect(minHeap.size).toBe(0);
-		});
-	});
-
-	describe('Heap Sort', () => {
-		it('Should sort an array in ASC order', () => {
-			const minHeap = new MinHeap({
-				inputs: [
-					7,
-					1,
-					10,
-					4,
-					8,
-					6,
-					2,
-					3,
-					5,
-					9,
-				],
-			});
-
-			const {size} = minHeap;
-			const result = [];
-
-			for (let i = 1; i <= size; i++) {
-				result.push(minHeap.extract());
-			}
-
-			expect(result).toEqual([1, 2, 3, 4, 5, 6, 7, 8, 9, 10]);
-		});
-	});
-
-	describe('Conversion to primitive', () => {
-		it('Should return separated by comma values in string conversion', () => {
-			const maxHeap = new MinHeap({
-				inputs: [1, 2, 3, 4, 5],
-			});
-			const string = String(maxHeap);
-
-			expect(string).toBe('1, 2, 3, 4, 5');
-		});
-
-		it('Should return the size in number conversion', () => {
-			const maxHeap = new MinHeap({
-				inputs: [1, 2, 3, 4, 5],
-			});
-			const number = Number(maxHeap);
-
-			expect(number).toBe(5);
-		});
-	});
-});