@gabrielrufino/cube 1.0.1

package/src/HashTableSeparateChaining/index.spec.ts

@@ -0,0 +1,173 @@
+import {describe, it, expect} from '@jest/globals';
+
+import HashTableSeparateChaining from './';
+import LinkedList from '../LinkedList';
+import HashTableSeparateChainingElement from './HashTableSeparateChainingElement';
+
+describe('HashTableSeparateChaining', () => {
+	it('Should create an empty hash table separate chaining without problems', () => {
+		const hashTableSeparateChaining = new HashTableSeparateChaining<number>();
+
+		expect(hashTableSeparateChaining.data).toEqual({});
+		expect(hashTableSeparateChaining.size).toBe(0);
+	});
+
+	it('Should create an filled hash table separate chaining without problems', () => {
+		const hashTableSeparateChaining = new HashTableSeparateChaining<number>({
+			first: 1,
+			tsrif: -1,
+			second: 2,
+		});
+
+		expect(hashTableSeparateChaining.data).toEqual({
+			36: new LinkedList(
+				new HashTableSeparateChainingElement('second', 2),
+			),
+			52: new LinkedList(
+				new HashTableSeparateChainingElement('first', 1),
+				new HashTableSeparateChainingElement('tsrif', -1),
+			),
+		});
+		expect(hashTableSeparateChaining.size).toBe(2);
+	});
+
+	describe('.put()', () => {
+		it('Should insert a new element in the hash table separate chaining', () => {
+			const hashTableSeparateChaining = new HashTableSeparateChaining({
+				first: 1,
+			});
+			hashTableSeparateChaining.put('second', 2);
+
+			expect(hashTableSeparateChaining.data).toEqual({
+				36: new LinkedList(
+					new HashTableSeparateChainingElement('second', 2),
+				),
+				52: new LinkedList(
+					new HashTableSeparateChainingElement('first', 1),
+				),
+			});
+			expect(hashTableSeparateChaining.size).toBe(2);
+		});
+
+		it('Should insert the new element in an existent linked list on collisions', () => {
+			const hashTableSeparateChaining = new HashTableSeparateChaining({
+				first: 1,
+				second: 2,
+			});
+			hashTableSeparateChaining.put('tsrif', -1);
+
+			expect(hashTableSeparateChaining.data).toEqual({
+				36: new LinkedList(
+					new HashTableSeparateChainingElement('second', 2),
+				),
+				52: new LinkedList(
+					new HashTableSeparateChainingElement('first', 1),
+					new HashTableSeparateChainingElement('tsrif', -1),
+				),
+			});
+			expect(hashTableSeparateChaining.size).toBe(2);
+		});
+
+		it('Should return the inserted element', () => {
+			const hashTableSeparateChaining = new HashTableSeparateChaining();
+			const returned = hashTableSeparateChaining.put('first', 1);
+
+			expect(returned).toBe(1);
+		});
+	});
+
+	describe('.get()', () => {
+		it('Should get an element by key', () => {
+			const hashTableSeparateChaining = new HashTableSeparateChaining({
+				first: 1,
+				second: 2,
+			});
+			const returned = hashTableSeparateChaining.get('first');
+
+			expect(returned).toEqual(new HashTableSeparateChainingElement('first', 1));
+		});
+
+		it('Should return null when the key is not in the hash table separate chaining', () => {
+			const hashTableSeparateChaining = new HashTableSeparateChaining({
+				first: 1,
+				second: 2,
+			});
+			const returned = hashTableSeparateChaining.get('third');
+
+			expect(returned).toBeNull();
+		});
+	});
+
+	describe('.remove()', () => {
+		it('Should remove an existent key value pair', () => {
+			const hashTableSeparateChaining = new HashTableSeparateChaining({
+				first: 1,
+				second: 2,
+			});
+			hashTableSeparateChaining.remove('first');
+
+			expect(hashTableSeparateChaining.data).toEqual({
+				36: new LinkedList(new HashTableSeparateChainingElement('second', 2)),
+			});
+			expect(hashTableSeparateChaining.size).toBe(1);
+		});
+
+		it('Should change nothing if the key is not in the hash table separate chaining', () => {
+			const hashTableSeparateChaining = new HashTableSeparateChaining({
+				first: 1,
+				second: 2,
+			});
+			hashTableSeparateChaining.remove('third');
+
+			expect(hashTableSeparateChaining.data).toEqual({
+				36: new LinkedList(new HashTableSeparateChainingElement('second', 2)),
+				52: new LinkedList(new HashTableSeparateChainingElement('first', 1)),
+			});
+			expect(hashTableSeparateChaining.size).toBe(2);
+		});
+
+		it('Should return the removed linked list', () => {
+			const hashTableSeparateChaining = new HashTableSeparateChaining({
+				first: 1,
+				second: 2,
+			});
+			const returned = hashTableSeparateChaining.remove('first');
+
+			expect(returned).toEqual(new HashTableSeparateChainingElement('first', 1));
+		});
+
+		it('Should return null when remove a non existent key', () => {
+			const hashTableSeparateChaining = new HashTableSeparateChaining({
+				first: 1,
+				second: 2,
+			});
+			const returned = hashTableSeparateChaining.remove('third');
+
+			expect(returned).toBeNull();
+		});
+	});
+
+	describe('Conversion to primitive', () => {
+		it('Should return separated by comma linked list in string conversion', () => {
+			const hashTableSeparateChaining = new HashTableSeparateChaining({
+				first: 1,
+				tsrif: -1,
+				second: 2,
+			});
+			const string = String(hashTableSeparateChaining);
+
+			expect(string).toBe('[ [Head] { second => 2}, [Head] { first => 1} => { tsrif => -1} ]');
+		});
+
+		it('Should return the size in number conversion', () => {
+			const hashTableSeparateChaining = new HashTableSeparateChaining({
+				first: 1,
+				tsrif: -1,
+				second: 2,
+			});
+			const string = Number(hashTableSeparateChaining);
+
+			expect(string).toBe(2);
+		});
+	});
+});

package/src/HashTableSeparateChaining/index.ts

@@ -0,0 +1,104 @@
+import HashTableSeparateChainingElement from './HashTableSeparateChainingElement';
+import IHashTableSeparateChaining from './IHashTableSeparateChaining';
+import IHashTableSeparateChainingData from './IHashTableSeparateChainingData';
+import IHashTableSeparateChainingInputs from './IHashTableSeparateChainingInputs';
+import LinkedList from '../LinkedList';
+
+export default class HashTableSeparateChaining<T = number> implements IHashTableSeparateChaining<T> {
+	private _maxSize: number;
+	private _data: LinkedList<HashTableSeparateChainingElement<T>>[];
+
+	constructor(
+		inputs: IHashTableSeparateChainingInputs<T> = {},
+		{maxSize} = {maxSize: 100},
+	) {
+		this._maxSize = maxSize;
+		this._data = new Array(this._maxSize);
+
+		for (const [key, value] of Object.entries(inputs)) {
+			this.put(key, value);
+		}
+	}
+
+	get data(): IHashTableSeparateChainingData<T> {
+		return this._data
+			.map((value, key) => ({key, value}))
+			.reduce((accumulator, current) => ({
+				...accumulator,
+				[current.key]: current.value,
+			}), {});
+	}
+
+	get size(): number {
+		return Reflect.ownKeys(this.data).length;
+	}
+
+	public put(key: string, value: T): T {
+		const linkedList = this._getLinkedListByKey(key);
+		const element = new HashTableSeparateChainingElement(key, value);
+
+		if (linkedList) {
+			linkedList.push(element);
+		} else {
+			const position = this._hashCode(key);
+			this._data[position] = new LinkedList(element);
+		}
+
+		return value;
+	}
+
+	public get(key: string): HashTableSeparateChainingElement<T> | null {
+		const linkedList = this._getLinkedListByKey(key);
+
+		if (linkedList) {
+			const element = linkedList.data.find(element => element.value.key === key);
+			return element?.value || null;
+		}
+
+		return null;
+	}
+
+	public remove(key: string): HashTableSeparateChainingElement<T> | null {
+		const linkedList = this._getLinkedListByKey(key);
+
+		if (linkedList) {
+			const index = linkedList.data.findIndex(element => element.value.key === key);
+			const element = linkedList.removeFromPosition(index);
+
+			if (linkedList.isEmpty) {
+				const position = this._hashCode(key);
+				Reflect.deleteProperty(this._data, position);
+			}
+
+			return element || null;
+		}
+
+		return null;
+	}
+
+	private _getLinkedListByKey(key: string): LinkedList<HashTableSeparateChainingElement<T>> | null {
+		const position = this._hashCode(key);
+		return Reflect.get(this.data, position) || null;
+	}
+
+	private _hashCode(key: string): number {
+		const code = key
+			.split('')
+			.map(character => character.charCodeAt(0))
+			.reduce((previous, current) => previous + current, 0);
+
+		return code % this._maxSize;
+	}
+
+	private [Symbol.toPrimitive](type: string): string | number | null {
+		if (type === 'string') {
+			return `[ ${Object.values(this.data).map(String).join(', ')} ]`;
+		}
+
+		if (type === 'number') {
+			return this.size;
+		}
+
+		return null;
+	}
+}

package/src/LinkedList/ILinkedList.ts

@@ -0,0 +1,15 @@
+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/src/LinkedList/ILinkedListItem.ts

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

package/src/LinkedList/Node.ts

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

package/src/LinkedList/index.spec.ts

@@ -0,0 +1,355 @@
+import {describe, it, expect} from '@jest/globals';
+
+import LinkedList from './';
+
+describe('LinkedList', () => {
+	it('Should create an empty linked list without problems', () => {
+		const linkedList = new LinkedList();
+
+		expect(linkedList.data).toEqual([]);
+		expect(linkedList.size).toBe(0);
+	});
+
+	it('Should create a filled linked list without problems', () => {
+		const linkedList = new LinkedList(1, 2, 3, 4);
+
+		expect(linkedList.data).toEqual([
+			{
+				value: 1,
+				next: 2,
+			},
+			{
+				value: 2,
+				next: 3,
+			},
+			{
+				value: 3,
+				next: 4,
+			},
+			{
+				value: 4,
+				next: null,
+			},
+		]);
+		expect(linkedList.size).toBe(4);
+	});
+
+	describe('.isEmpty', () => {
+		it('Should return true when there is no element in the linked list', () => {
+			const linkedList = new LinkedList();
+
+			expect(linkedList.isEmpty).toBe(true);
+		});
+
+		it('Should return false when the is at least one element in the linked list', () => {
+			const linkedList = new LinkedList(1, 2, 3, 4);
+
+			expect(linkedList.isEmpty).toBe(false);
+		});
+	});
+
+	describe('.push()', () => {
+		it('Should push a new element', () => {
+			const linkedList = new LinkedList();
+
+			linkedList.push(1);
+			linkedList.push(2);
+			linkedList.push(3);
+			linkedList.push(4);
+
+			expect(linkedList.data).toEqual([
+				{
+					value: 1,
+					next: 2,
+				},
+				{
+					value: 2,
+					next: 3,
+				},
+				{
+					value: 3,
+					next: 4,
+				},
+				{
+					value: 4,
+					next: null,
+				},
+			]);
+			expect(linkedList.size).toBe(4);
+		});
+
+		it('Should return the pushed element', () => {
+			const linkedList = new LinkedList();
+			const returned = linkedList.push(1);
+
+			expect(returned).toBe(1);
+		});
+	});
+
+	describe('.removeFromPosition()', () => {
+		it('Should return undefined when given a negative position', () => {
+			const linkedList = new LinkedList(1, 2, 3, 4);
+			const returned = linkedList.removeFromPosition(-1);
+
+			expect(returned).toBeUndefined();
+		});
+
+		it('Should return undefined when given a position equal size', () => {
+			const linkedList = new LinkedList(1, 2, 3, 4);
+			const returned = linkedList.removeFromPosition(linkedList.size);
+
+			expect(returned).toBeUndefined();
+		});
+
+		it('Should return undefined when given a position larger than size', () => {
+			const linkedList = new LinkedList(1, 2, 3, 4);
+			const returned = linkedList.removeFromPosition(linkedList.size + 1);
+
+			expect(returned).toBeUndefined();
+		});
+
+		it('Should remove item from the head', () => {
+			const linkedList = new LinkedList(1, 2, 3, 4);
+			linkedList.removeFromPosition(0);
+
+			expect(linkedList.data).toEqual([
+				{
+					value: 2,
+					next: 3,
+				},
+				{
+					value: 3,
+					next: 4,
+				},
+				{
+					value: 4,
+					next: null,
+				},
+			]);
+		});
+
+		it('Should remove item from the middle of the linked list', () => {
+			const linkedList = new LinkedList(1, 2, 3, 4);
+			linkedList.removeFromPosition(2);
+
+			expect(linkedList.data).toEqual([
+				{
+					value: 1,
+					next: 2,
+				},
+				{
+					value: 2,
+					next: 4,
+				},
+				{
+					value: 4,
+					next: null,
+				},
+			]);
+		});
+
+		it('Should remove item from the last position of the linked list', () => {
+			const linkedList = new LinkedList(1, 2, 3, 4);
+			linkedList.removeFromPosition(linkedList.size - 1);
+
+			expect(linkedList.data).toEqual([
+				{
+					value: 1,
+					next: 2,
+				},
+				{
+					value: 2,
+					next: 3,
+				},
+				{
+					value: 3,
+					next: null,
+				},
+			]);
+		});
+	});
+
+	describe('.getFromPosition()', () => {
+		it('Should get then element at a valid position', () => {
+			const linkedList = new LinkedList(1, 2, 3, 4);
+			const returned = linkedList.getFromPosition(2);
+
+			expect(returned).toEqual({
+				value: 3,
+				next: 4,
+			});
+		});
+	});
+
+	describe('.insertInPosition()', () => {
+		it('Should return undefined when receive a negative position', () => {
+			const linkedList = new LinkedList(1, 2, 3, 4);
+			const returned = linkedList.insertInPosition(5, -1);
+
+			expect(returned).toBeUndefined();
+		});
+
+		it('Should return undefined when receive a position larger than the size', () => {
+			const linkedList = new LinkedList(1, 2, 3, 4);
+			const returned = linkedList.insertInPosition(5, 10);
+
+			expect(returned).toBeUndefined();
+		});
+
+		it('Should insert an element in the head when receive position 0', () => {
+			const linkedList = new LinkedList(1);
+			linkedList.insertInPosition(0, 0);
+
+			expect(linkedList.data).toEqual([
+				{
+					value: 0,
+					next: 1,
+				},
+				{
+					value: 1,
+					next: null,
+				},
+			]);
+		});
+
+		it('Should insert an element in the middle of the linked list', () => {
+			const linkedList = new LinkedList(1, 3);
+			linkedList.insertInPosition(2, 1);
+
+			expect(linkedList.data).toEqual([
+				{
+					value: 1,
+					next: 2,
+				},
+				{
+					value: 2,
+					next: 3,
+				},
+				{
+					value: 3,
+					next: null,
+				},
+			]);
+		});
+
+		it('Should insert an element in the penultimate position', () => {
+			const linkedList = new LinkedList(1, 2, 4);
+			linkedList.insertInPosition(3, linkedList.size - 1);
+
+			expect(linkedList.data).toEqual([
+				{
+					value: 1,
+					next: 2,
+				},
+				{
+					value: 2,
+					next: 3,
+				},
+				{
+					value: 3,
+					next: 4,
+				},
+				{
+					value: 4,
+					next: null,
+				},
+			]);
+		});
+
+		it('Should insert an element in the end of the linked list, just like a push', () => {
+			const linkedList = new LinkedList(1, 2);
+			linkedList.insertInPosition(3, linkedList.size);
+
+			expect(linkedList.data).toEqual([
+				{
+					value: 1,
+					next: 2,
+				},
+				{
+					value: 2,
+					next: 3,
+				},
+				{
+					value: 3,
+					next: null,
+				},
+			]);
+		});
+
+		it('Should increase the size by one', () => {
+			const linkedList = new LinkedList(1, 2, 3, 4);
+			const {size} = linkedList;
+			linkedList.insertInPosition(5, linkedList.size);
+
+			expect(linkedList.size).toBe(size + 1);
+		});
+	});
+
+	describe('.positionOf()', () => {
+		it('Should return undefined when receive an element not found in linked list', () => {
+			const linkedList = new LinkedList(1, 2, 3, 4);
+			const position = linkedList.positionOf(5);
+
+			expect(position).toBeUndefined();
+		});
+
+		it('Should return the correct position of an element', () => {
+			const linkedList = new LinkedList(1, 2, 3, 4);
+			const position = linkedList.positionOf(3);
+
+			expect(position).toBe(2);
+		});
+	});
+
+	describe('.remove()', () => {
+		it('Should remove an element from linked list', () => {
+			const linkedList = new LinkedList(1, 2, 3, 4);
+			linkedList.remove(3);
+
+			expect(linkedList.data).toEqual([
+				{
+					value: 1,
+					next: 2,
+				},
+				{
+					value: 2,
+					next: 4,
+				},
+				{
+					value: 4,
+					next: null,
+				},
+			]);
+		});
+
+		it('Should return the removed element', () => {
+			const linkedList = new LinkedList(1, 2, 3, 4);
+			const returned = linkedList.remove(3);
+
+			expect(returned).toBe(3);
+		});
+
+		it('Should return undefined when the element doesn\'t belongs to the linked list', () => {
+			const linkedList = new LinkedList(1, 2, 3, 4);
+			const returned = linkedList.remove(5);
+
+			expect(returned).toBeUndefined();
+		});
+	});
+
+	describe('Conversion to primitive', () => {
+		it('Should return arrow-separated elements in string conversion', () => {
+			const linkedList = new LinkedList(1, 2, 3, 4);
+			const string = String(linkedList);
+
+			expect(string).toBe('[Head] 1 => 2 => 3 => 4');
+		});
+
+		it('Should return the linked list size in number conversion', () => {
+			const linkedList = new LinkedList(1, 2, 3, 4);
+			const number = Number(linkedList);
+
+			expect(number).toBe(4);
+		});
+	});
+});