@gabrielrufino/cube 1.0.1

package/src/DoublyLinkedList/index.spec.ts

@@ -0,0 +1,478 @@
+import {describe, it, expect} from '@jest/globals';
+
+import DoublyLinkedList from './';
+
+describe('DoublyLinkedList', () => {
+	it('Should create an empty doubly linked list with no problems', () => {
+		const doublyLinkedList = new DoublyLinkedList();
+
+		expect(doublyLinkedList.data).toEqual([]);
+		expect(doublyLinkedList.size).toBe(0);
+	});
+
+	it('Should creat a filled doubly linked list with no problems', () => {
+		const doublyLinkedList = new DoublyLinkedList(1, 2, 3, 4);
+
+		expect(doublyLinkedList.data).toEqual([
+			{
+				previous: null,
+				value: 1,
+				next: 2,
+			},
+			{
+				previous: 1,
+				value: 2,
+				next: 3,
+			},
+			{
+				previous: 2,
+				value: 3,
+				next: 4,
+			},
+			{
+				previous: 3,
+				value: 4,
+				next: null,
+			},
+		]);
+		expect(doublyLinkedList.size).toBe(4);
+	});
+
+	describe('.push()', () => {
+		it('Should push a new element in a filled doubly linked list', () => {
+			const doublyLinkedList = new DoublyLinkedList(1, 2, 3, 4);
+			doublyLinkedList.push(5);
+
+			expect(doublyLinkedList.data).toEqual([
+				{
+					previous: null,
+					value: 1,
+					next: 2,
+				},
+				{
+					previous: 1,
+					value: 2,
+					next: 3,
+				},
+				{
+					previous: 2,
+					value: 3,
+					next: 4,
+				},
+				{
+					previous: 3,
+					value: 4,
+					next: 5,
+				},
+				{
+					previous: 4,
+					value: 5,
+					next: null,
+				},
+			]);
+			expect(doublyLinkedList.size).toBe(5);
+		});
+
+		it('Should push a new element in an empty doubly linked list', () => {
+			const doublyLinkedList = new DoublyLinkedList();
+			doublyLinkedList.push(1);
+
+			expect(doublyLinkedList.data).toEqual([
+				{
+					previous: null,
+					value: 1,
+					next: null,
+				},
+			]);
+			expect(doublyLinkedList.size).toBe(1);
+		});
+
+		it('Should return the new element', () => {
+			const doublyLinkedList = new DoublyLinkedList(1, 2, 3, 4);
+			const returned = doublyLinkedList.push(5);
+
+			expect(returned).toBe(5);
+		});
+	});
+
+	describe('.getFromPosition()', () => {
+		it('Should return undefined when receive a position lower than zero', () => {
+			const doublyLinkedList = new DoublyLinkedList(1, 2, 3, 4);
+			const returned = doublyLinkedList.getFromPosition(-1);
+
+			expect(returned).toBeUndefined();
+		});
+
+		it('Should return undefined when receive a position equals the size', () => {
+			const doublyLinkedList = new DoublyLinkedList(1, 2, 3, 4);
+			const returned = doublyLinkedList.getFromPosition(4);
+
+			expect(returned).toBeUndefined();
+		});
+
+		it('Should return undefined when receive a position greater than the size', () => {
+			const doublyLinkedList = new DoublyLinkedList(1, 2, 3, 4);
+			const returned = doublyLinkedList.getFromPosition(5);
+
+			expect(returned).toBeUndefined();
+		});
+
+		it('Should return the correct item when closest to the head', () => {
+			const doublyLinkedList = new DoublyLinkedList(1, 2, 3, 4);
+			const returned = doublyLinkedList.getFromPosition(1);
+
+			expect(returned).toEqual({
+				previous: 1,
+				value: 2,
+				next: 3,
+			});
+		});
+
+		it('Should return the correct item when closest to the tail', () => {
+			const doublyLinkedList = new DoublyLinkedList(1, 2, 3, 4);
+			const returned = doublyLinkedList.getFromPosition(2);
+
+			expect(returned).toEqual({
+				previous: 2,
+				value: 3,
+				next: 4,
+			});
+		});
+	});
+
+	describe('.positionOf()', () => {
+		it('Should return the position of an element', () => {
+			const doublyLinkedList = new DoublyLinkedList(1, 2, 3, 4);
+			const returned = doublyLinkedList.positionOf(3);
+
+			expect(returned).toBe(2);
+		});
+
+		it('Should return undefined when the element is not in the doubly linked list', () => {
+			const doublyLinkedList = new DoublyLinkedList(1, 2, 3, 4);
+			const returned = doublyLinkedList.positionOf(5);
+
+			expect(returned).toBeUndefined();
+		});
+	});
+
+	describe('.insertInPosition()', () => {
+		it('Should return undefined when receive a negative position', () => {
+			const doublyLinkedList = new DoublyLinkedList();
+			const returned = doublyLinkedList.insertInPosition(1, -1);
+
+			expect(returned).toBeUndefined();
+			expect(doublyLinkedList.data).toEqual([]);
+			expect(doublyLinkedList.size).toBe(0);
+		});
+
+		it('Should return undefined when receive a position greater than the size', () => {
+			const doublyLinkedList = new DoublyLinkedList();
+			const returned = doublyLinkedList.insertInPosition(1, doublyLinkedList.size + 1);
+
+			expect(returned).toBeUndefined();
+			expect(doublyLinkedList.data).toEqual([]);
+			expect(doublyLinkedList.size).toBe(0);
+		});
+
+		it('Should insert a new element in the first position', () => {
+			const doublyLinkedList = new DoublyLinkedList(2);
+			doublyLinkedList.insertInPosition(1, 0);
+
+			expect(doublyLinkedList.data).toEqual([
+				{
+					previous: null,
+					value: 1,
+					next: 2,
+				},
+				{
+					previous: 1,
+					value: 2,
+					next: null,
+				},
+			]);
+			expect(doublyLinkedList.size).toBe(2);
+		});
+
+		it('Should insert a new element in the penultimate position', () => {
+			const doublyLinkedList = new DoublyLinkedList(1, 3);
+			doublyLinkedList.insertInPosition(2, 1);
+
+			expect(doublyLinkedList.data).toEqual([
+				{
+					previous: null,
+					value: 1,
+					next: 2,
+				},
+				{
+					previous: 1,
+					value: 2,
+					next: 3,
+				},
+				{
+					previous: 2,
+					value: 3,
+					next: null,
+				},
+			]);
+			expect(doublyLinkedList.size).toBe(3);
+		});
+
+		it('Should insert a new element in the last position', () => {
+			const doublyLinkedList = new DoublyLinkedList(1, 2);
+			doublyLinkedList.insertInPosition(3, 2);
+
+			expect(doublyLinkedList.data).toEqual([
+				{
+					previous: null,
+					value: 1,
+					next: 2,
+				},
+				{
+					previous: 1,
+					value: 2,
+					next: 3,
+				},
+				{
+					previous: 2,
+					value: 3,
+					next: null,
+				},
+			]);
+			expect(doublyLinkedList.size).toBe(3);
+		});
+
+		it('Should insert a new element in a position closest to the head', () => {
+			const doublyLinkedList = new DoublyLinkedList(1, 3, 4, 5);
+			doublyLinkedList.insertInPosition(2, 1);
+
+			expect(doublyLinkedList.data).toEqual([
+				{
+					previous: null,
+					value: 1,
+					next: 2,
+				},
+				{
+					previous: 1,
+					value: 2,
+					next: 3,
+				},
+				{
+					previous: 2,
+					value: 3,
+					next: 4,
+				},
+				{
+					previous: 3,
+					value: 4,
+					next: 5,
+				},
+				{
+					previous: 4,
+					value: 5,
+					next: null,
+				},
+			]);
+			expect(doublyLinkedList.size).toBe(5);
+		});
+
+		it('Should insert a new element in a position closest to the head', () => {
+			const doublyLinkedList = new DoublyLinkedList(1, 2, 4, 5);
+			doublyLinkedList.insertInPosition(3, 2);
+
+			expect(doublyLinkedList.data).toEqual([
+				{
+					previous: null,
+					value: 1,
+					next: 2,
+				},
+				{
+					previous: 1,
+					value: 2,
+					next: 3,
+				},
+				{
+					previous: 2,
+					value: 3,
+					next: 4,
+				},
+				{
+					previous: 3,
+					value: 4,
+					next: 5,
+				},
+				{
+					previous: 4,
+					value: 5,
+					next: null,
+				},
+			]);
+			expect(doublyLinkedList.size).toBe(5);
+		});
+
+		it('Should return the inserted element', () => {
+			const doublyLinkedList = new DoublyLinkedList(1, 2, 3, 5);
+			const returned = doublyLinkedList.insertInPosition(4, 3);
+
+			expect(returned).toBe(4);
+		});
+	});
+
+	describe('.remove()', () => {
+		it('Should remove an element in the first position', () => {
+			const doublyLinkedList = new DoublyLinkedList(1, 2, 3, 4);
+			doublyLinkedList.remove(1);
+
+			expect(doublyLinkedList.data).toEqual([
+				{
+					previous: null,
+					value: 2,
+					next: 3,
+				},
+				{
+					previous: 2,
+					value: 3,
+					next: 4,
+				},
+				{
+					previous: 3,
+					value: 4,
+					next: null,
+				},
+			]);
+			expect(doublyLinkedList.size).toBe(3);
+		});
+
+		it('Should remove an element in the last position', () => {
+			const doublyLinkedList = new DoublyLinkedList(1, 2, 3, 4);
+			doublyLinkedList.remove(4);
+
+			expect(doublyLinkedList.data).toEqual([
+				{
+					previous: null,
+					value: 1,
+					next: 2,
+				},
+				{
+					previous: 1,
+					value: 2,
+					next: 3,
+				},
+				{
+					previous: 2,
+					value: 3,
+					next: null,
+				},
+			]);
+			expect(doublyLinkedList.size).toBe(3);
+		});
+
+		it('Should remove an element in a middle position', () => {
+			const doublyLinkedList = new DoublyLinkedList(1, 2, 3, 4);
+			doublyLinkedList.remove(3);
+
+			expect(doublyLinkedList.data).toEqual([
+				{
+					previous: null,
+					value: 1,
+					next: 2,
+				},
+				{
+					previous: 1,
+					value: 2,
+					next: 4,
+				},
+				{
+					previous: 2,
+					value: 4,
+					next: null,
+				},
+			]);
+			expect(doublyLinkedList.size).toBe(3);
+		});
+
+		it('Should return the removed element', () => {
+			const doublyLinkedList = new DoublyLinkedList(1, 2, 3, 4);
+			const returned = doublyLinkedList.remove(2);
+
+			expect(returned).toBe(2);
+		});
+
+		it('Should return undefined when the element is not in the doubly linked list', () => {
+			const doublyLinkedList = new DoublyLinkedList(1, 2, 3, 4);
+			const returned = doublyLinkedList.remove(5);
+
+			expect(returned).toBeUndefined();
+		});
+	});
+
+	describe('.removeFromPosition()', () => {
+		it('Should return undefined when receive a negative position', () => {
+			const doublyLinkedList = new DoublyLinkedList(1, 2, 3, 4);
+			const returned = doublyLinkedList.removeFromPosition(-1);
+
+			expect(returned).toBeUndefined();
+		});
+
+		it('Should return undefined when receive a position equals the size', () => {
+			const doublyLinkedList = new DoublyLinkedList(1, 2, 3, 4);
+			const returned = doublyLinkedList.removeFromPosition(doublyLinkedList.size);
+
+			expect(returned).toBeUndefined();
+		});
+
+		it('Should return undefined when receive a position greater than the size', () => {
+			const doublyLinkedList = new DoublyLinkedList(1, 2, 3, 4);
+			const returned = doublyLinkedList.removeFromPosition(doublyLinkedList.size + 1);
+
+			expect(returned).toBeUndefined();
+		});
+
+		it('Should remove an element from position', () => {
+			const doublyLinkedList = new DoublyLinkedList(1, 2, 3, 4);
+			doublyLinkedList.removeFromPosition(2);
+
+			expect(doublyLinkedList.data).toEqual([
+				{
+					previous: null,
+					value: 1,
+					next: 2,
+				},
+				{
+					previous: 1,
+					value: 2,
+					next: 4,
+				},
+				{
+					previous: 2,
+					value: 4,
+					next: null,
+				},
+			]);
+			expect(doublyLinkedList.size).toBe(3);
+		});
+
+		it('Should return the removed element', () => {
+			const doublyLinkedList = new DoublyLinkedList(1, 2, 3, 4);
+			const returned = doublyLinkedList.removeFromPosition(3);
+
+			expect(returned).toBe(4);
+		});
+	});
+
+	describe('Conversion to primitive', () => {
+		it('Should return double-arrow-separated elements in string conversion', () => {
+			const doublyLinkedList = new DoublyLinkedList(1, 2, 3, 4);
+			const string = String(doublyLinkedList);
+
+			expect(string).toBe('[Head] 1 <=> 2 <=> 3 <=> 4 [Tail]');
+		});
+
+		it('Should return the doubly linked list size in number conversion', () => {
+			const doublyLinkedList = new DoublyLinkedList(1, 2, 3, 4);
+			const number = Number(doublyLinkedList);
+
+			expect(number).toBe(4);
+		});
+	});
+});

package/src/DoublyLinkedList/index.ts

@@ -0,0 +1,250 @@
+import IDoublyLinkedList, {IDoublyLinkedListItem} from './IDoublyLinkedList';
+import Node from './Node';
+
+export default class DoublyLinkedList<T = number> implements IDoublyLinkedList<T> {
+	private _head: Node<T> | null = null;
+	private _tail: Node<T> | null = null;
+	private _size: number = 0;
+
+	constructor(...inputs: T[]) {
+		if (inputs.length) {
+			const nodes = inputs.map(input => new Node(input));
+
+			for (let i = 0; i < inputs.length; i++) {
+				nodes[i].previous = nodes[i - 1] || null;
+				nodes[i].next = nodes[i + 1] || null;
+			}
+
+			this._head = nodes[0];
+			this._tail = nodes[nodes.length - 1];
+			this._size = inputs.length;
+		}
+	}
+
+	public get data(): IDoublyLinkedListItem<T>[] {
+		let current = this._head;
+		const data = [];
+
+		while (current) {
+			data.push({
+				previous: current.previous?.value || null,
+				value: current.value,
+				next: current.next?.value || null,
+			});
+			current = current.next;
+		}
+
+		return data;
+	}
+
+	public get size(): number {
+		return this._size;
+	}
+
+	/**
+	 * Complexity: O(1)
+	 */
+	public push(element: T): T {
+		const node = new Node(element);
+
+		if (this._tail) {
+			this._tail.next = node;
+			node.previous = this._tail;
+		} else {
+			this._head = node;
+			this._tail = node;
+		}
+
+		this._size += 1;
+		return element;
+	}
+
+	/**
+	 * Complexity: O(n/2)
+	 */
+	public getFromPosition(position: number): IDoublyLinkedListItem<T> | undefined {
+		if (position < 0 || position >= this._size) {
+			return undefined;
+		}
+
+		const distanceToTheHead = position;
+		const distanceToTheTail = this.size - position - 1;
+		let current: Node<T> | null;
+
+		if (distanceToTheTail > distanceToTheHead) {
+			current = this._head;
+
+			for (let i = 0; i < position; i++) {
+				current = current?.next || null;
+			}
+		} else {
+			current = this._tail;
+
+			for (let i = this.size - 1; i > position; i--) {
+				current = current?.previous || null;
+			}
+		}
+
+		if (current?.value) {
+			return {
+				previous: current?.previous?.value || null,
+				value: current?.value,
+				next: current?.next?.value || null,
+			};
+		}
+	}
+
+	public positionOf(element: T): number | undefined {
+		let current = this._head;
+		let position = 0;
+
+		while (current && current.value !== element) {
+			current = current.next;
+			position += 1;
+		}
+
+		return position === this.size ? undefined : position;
+	}
+
+	/**
+	 * Complexity: O(n)
+	 */
+	public insertInPosition(element: T, position: number): T | undefined {
+		if (position < 0 || position > this.size) {
+			return undefined;
+		}
+
+		const node = new Node<T>(element);
+
+		if (position === 0 && this._head) {
+			node.next = this._head;
+			this._head.previous = node;
+			this._head = node;
+
+			this._size += 1;
+
+			return element;
+		}
+
+		if (position === this.size - 1 && this._tail && this._tail.previous) {
+			this._tail.previous.next = node;
+			node.previous = this._tail?.previous || null;
+			node.next = this._tail;
+			this._tail.previous = node;
+
+			this._size += 1;
+
+			return element;
+		}
+
+		if (position === this.size && this._tail) {
+			node.previous = this._tail;
+			this._tail.next = node;
+			this._tail = node;
+
+			this._size += 1;
+
+			return element;
+		}
+
+		const way = this._findFasterWayToPosition(position);
+		let current: Node<T> | null;
+
+		if (way === 'ASC') {
+			current = this._head;
+
+			for (let i = 0; i < position; i++) {
+				current = current?.next || null;
+			}
+		} else {
+			current = this._tail;
+
+			for (let i = this.size - 1; i > position; i--) {
+				current = current?.previous || null;
+			}
+		}
+
+		if (current && current.previous) {
+			current.previous.next = node;
+			node.previous = current.previous;
+			node.next = current;
+			current.previous = node;
+		}
+
+		this._size += 1;
+
+		return element;
+	}
+
+	/**
+	 * Complexity: O(n)
+	 */
+	public remove(element: T): T | undefined {
+		let current = this._head;
+
+		while (current && current.value !== element) {
+			current = current.next;
+		}
+
+		if (current) {
+			if (current.previous) {
+				current.previous.next = current.next;
+			}
+
+			if (current.next) {
+				current.next.previous = current.previous;
+			}
+
+			if (current === this._head) {
+				this._head = current.next;
+			}
+
+			if (current === this._tail) {
+				this._tail = current.previous;
+			}
+
+			this._size -= 1;
+
+			return current.value;
+		}
+
+		return undefined;
+	}
+
+	/**
+	 * Complexity: O(n)
+	 */
+	public removeFromPosition(position: number): T | undefined {
+		const item = this.getFromPosition(position);
+
+		if (item) {
+			this.remove(item.value);
+			return item.value;
+		}
+
+		return undefined;
+	}
+
+	private _findFasterWayToPosition(position: number): 'ASC' | 'DESC' {
+		const distanceToTheHead = position;
+		const distanceToTheTail = this.size - position - 1;
+
+		if (distanceToTheTail > distanceToTheHead) {
+			return 'ASC';
+		}
+
+		return 'DESC';
+	}
+
+	private [Symbol.toPrimitive](type: string): string | number | null {
+		if (type === 'string') {
+			return `[Head] ${this.data.map(({value}) => value).join(' <=> ')} [Tail]`;
+		}
+
+		if (type === 'number') {
+			return this.size;
+		}
+
+		return null;
+	}
+}

package/src/Graph/GraphNodeNotFoundError.ts

@@ -0,0 +1,7 @@
+export default class GraphNodeNotFoundError extends Error {
+	constructor(node: string) {
+		super(`Node ${node} not found`);
+
+		this.name = 'GraphNodeNotFoundError';
+	}
+}