@gabrielrufino/cube 1.0.1

package/src/HashTable/index.ts

@@ -0,0 +1,78 @@
+import IHashTable from './IHashTable';
+import IHashTableData from './IHashTableData';
+import IHashTableInputs from './IHashTableInputs';
+import IHashTableOptions from './IHashTableOptions';
+
+export default class HashTable<T = number> implements IHashTable<T> {
+	private _maxSize: number;
+	private _data: T[];
+
+	constructor(
+		inputs: IHashTableInputs<T> = {},
+		{maxSize = 100}: IHashTableOptions = {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(): IHashTableData<T> {
+		return this._data
+			.map((value, index) => ({index, value}))
+			.reduce((accumulator, current) => ({
+				...accumulator,
+				[current.index]: current.value,
+			}), {});
+	}
+
+	get size(): number {
+		return Reflect.ownKeys(this.data).length;
+	}
+
+	public put(key: string, value: T): T {
+		const position = this._hashCode(key);
+		this._data[position] = value;
+		return value;
+	}
+
+	public get(key: string): T | null {
+		const position = this._hashCode(key);
+		return this.data[position] || null;
+	}
+
+	public remove(key: string): T | null {
+		const value = this.get(key);
+
+		if (value) {
+			const position = this._hashCode(key);
+			Reflect.deleteProperty(this._data, position);
+			return value;
+		}
+
+		return 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.entries(this.data).map(([key, value]) => `${key} => ${value}`).join(', ')} ]`;
+		}
+
+		if (type === 'number') {
+			return this.size;
+		}
+
+		return null;
+	}
+}

package/src/HashTableLinearProbing/HashTableLinearProbingElement.spec.ts

@@ -0,0 +1,28 @@
+import {describe, it, expect} from '@jest/globals';
+
+import HashTableLinearProbingElement from './HashTableLinearProbingElement';
+
+describe('HashTableLinearProbingElement', () => {
+	it('Should create a hash table linear probing element without problems', () => {
+		const hashTableLinearProbingElement = new HashTableLinearProbingElement('key', 10);
+
+		expect(hashTableLinearProbingElement.key).toBe('key');
+		expect(hashTableLinearProbingElement.value).toBe(10);
+	});
+
+	describe('Conversion to primitive', () => {
+		it('Should return the key value pair separated by arrow in string conversion', () => {
+			const hashTableLinearProbingElement = new HashTableLinearProbingElement('key', 'value');
+			const string = String(hashTableLinearProbingElement);
+
+			expect(string).toBe('{ key => value }');
+		});
+
+		it('Should return the number 2 in number conversion', () => {
+			const hashTableLinearProbingElement = new HashTableLinearProbingElement('key', 'value');
+			const number = Number(hashTableLinearProbingElement);
+
+			expect(number).toBe(2);
+		});
+	});
+});

package/src/HashTableLinearProbing/HashTableLinearProbingElement.ts

@@ -0,0 +1,18 @@
+/* eslint-disable no-unused-vars */
+/* eslint-disable no-useless-constructor */
+
+export default class HashTableLinearProbingElement<T> {
+	constructor(
+		public key: string,
+		public value: T,
+	) {}
+
+	[Symbol.toPrimitive](type: 'string' | 'number'): string | number | null {
+		const options = {
+			string:	`{ ${this.key} => ${this.value} }`,
+			number: 2,
+		};
+
+		return options[type] || null;
+	}
+}

package/src/HashTableLinearProbing/IHashTableLinearProbing.ts

@@ -0,0 +1,11 @@
+import IHashTableLinearProbingData from './IHashTableLinearProbingData';
+
+interface IHashTableLinearProbing<T> {
+	get data(): IHashTableLinearProbingData<T>;
+	get size(): number;
+	put(_key: string, _value: T): T | null;
+	get(_key: string): T | null;
+	remove(_key: string): T | null;
+}
+
+export default IHashTableLinearProbing;

package/src/HashTableLinearProbing/IHashTableLinearProbingData.ts

@@ -0,0 +1,7 @@
+import HashTableLinearProbingElement from './HashTableLinearProbingElement';
+
+interface IHashTableLinearProbingData<T> {
+  [index: number]: HashTableLinearProbingElement<T>
+}
+
+export default IHashTableLinearProbingData;

package/src/HashTableLinearProbing/IHashTableLinearProbingInputs.ts

@@ -0,0 +1,5 @@
+interface IHashTableLinearProbingInputs<T> {
+	[key: string]: T;
+}
+
+export default IHashTableLinearProbingInputs;

package/src/HashTableLinearProbing/IHashTableLinearProbingOptions.ts

@@ -0,0 +1,5 @@
+interface IHashTableLinearProbingOptions {
+	maxSize: number;
+}
+
+export default IHashTableLinearProbingOptions;

package/src/HashTableLinearProbing/index.spec.ts

@@ -0,0 +1,266 @@
+import {describe, it, expect} from '@jest/globals';
+
+import HashTableLinearProbing from './';
+import HashTableLinearProbingElement from './HashTableLinearProbingElement';
+
+describe('HashTableLinearProbing', () => {
+	it('Should create an empty hash table linear probing without problems', () => {
+		const hashTableLinearProbing = new HashTableLinearProbing();
+
+		expect(hashTableLinearProbing.data).toEqual({});
+		expect(hashTableLinearProbing.size).toBe(0);
+	});
+
+	it('Should create a filled hash table linear probing without problems', () => {
+		const hashTableLinearProbing = new HashTableLinearProbing({
+			first: 1,
+			second: 2,
+		});
+
+		expect(hashTableLinearProbing.data).toEqual({
+			36: new HashTableLinearProbingElement('second', 2),
+			52: new HashTableLinearProbingElement('first', 1),
+		});
+		expect(hashTableLinearProbing.size).toBe(2);
+	});
+
+	describe('.put()', () => {
+		it('Should insert a new element', () => {
+			const hashTableLinearProbing = new HashTableLinearProbing({
+				first: 1,
+			});
+			hashTableLinearProbing.put('second', 2);
+
+			expect(hashTableLinearProbing.data).toEqual({
+				36: new HashTableLinearProbingElement('second', 2),
+				52: new HashTableLinearProbingElement('first', 1),
+			});
+			expect(hashTableLinearProbing.size).toBe(2);
+		});
+
+		it('Should return the inserted element', () => {
+			const hashTableLinearProbing = new HashTableLinearProbing({
+				first: 1,
+			});
+			const returned = hashTableLinearProbing.put('second', 2);
+
+			expect(returned).toBe(2);
+		});
+
+		it('Should change nothing when the hash table linear probing is full', () => {
+			const hashTableLinearProbing = new HashTableLinearProbing({
+				first: 1,
+				second: 2,
+			}, {
+				maxSize: 2,
+			});
+			hashTableLinearProbing.put('third', 3);
+
+			expect(hashTableLinearProbing.data).toEqual({
+				0: new HashTableLinearProbingElement('first', 1),
+				1: new HashTableLinearProbingElement('second', 2),
+			});
+			expect(hashTableLinearProbing.size).toBe(2);
+		});
+
+		it('Should return null when the hash table linear probing is full', () => {
+			const hashTableLinearProbing = new HashTableLinearProbing({
+				first: 1,
+				second: 2,
+			}, {
+				maxSize: 2,
+			});
+			const returned = hashTableLinearProbing.put('third', 3);
+
+			expect(returned).toBeNull();
+		});
+
+		it('Should put the new element in the next available position in collision case', () => {
+			const hashTableLinearProbing = new HashTableLinearProbing({
+				first: 1,
+			});
+			hashTableLinearProbing.put('tsrif', -1);
+
+			expect(hashTableLinearProbing.data).toEqual({
+				52: new HashTableLinearProbingElement('first', 1),
+				53: new HashTableLinearProbingElement('tsrif', -1),
+			});
+			expect(hashTableLinearProbing.size).toBe(2);
+		});
+	});
+
+	describe('.get()', () => {
+		it('Should return the value of the key', () => {
+			const hashTableLinearProbing = new HashTableLinearProbing({
+				first: 1,
+				second: 2,
+			});
+			const returned = hashTableLinearProbing.get('second');
+
+			expect(returned).toBe(2);
+		});
+
+		it('Should return the correct value in case of collisions', () => {
+			const hashTableLinearProbing = new HashTableLinearProbing({
+				first: 1,
+				tsrif: -1,
+			});
+			const returned = hashTableLinearProbing.get('tsrif');
+
+			expect(returned).toBe(-1);
+		});
+
+		it('Should return null when the key is not in the hash table linear probing', () => {
+			const hashTableLinearProbing = new HashTableLinearProbing({
+				first: 1,
+				second: 2,
+			});
+			const returned = hashTableLinearProbing.get('third');
+
+			expect(returned).toBeNull();
+		});
+
+		it('Should return null when the key is not in a full hash table linear probing', () => {
+			const hashTableLinearProbing = new HashTableLinearProbing({
+				first: 1,
+				second: 2,
+			}, {
+				maxSize: 2,
+			});
+			const returned = hashTableLinearProbing.get('third');
+
+			expect(returned).toBeNull();
+		});
+
+		it('Should return null for any key in empty hash table linear probing', () => {
+			const hashTableLinearProbing = new HashTableLinearProbing();
+			const returned = hashTableLinearProbing.get('first');
+
+			expect(returned).toBeNull();
+		});
+	});
+
+	describe('.remove()', () => {
+		it('Should remove an element', () => {
+			const hashTableLinearProbing = new HashTableLinearProbing({
+				first: 1,
+				second: 2,
+			});
+			hashTableLinearProbing.remove('second');
+
+			expect(hashTableLinearProbing.data).toEqual({
+				52: new HashTableLinearProbingElement('first', 1),
+			});
+			expect(hashTableLinearProbing.size).toBe(1);
+		});
+
+		it('Should return the removed value', () => {
+			const hashTableLinearProbing = new HashTableLinearProbing({
+				first: 1,
+				second: 2,
+			});
+			const returned = hashTableLinearProbing.remove('second');
+
+			expect(returned).toBe(2);
+		});
+
+		it('Should change nothing if the key is not in the hash table linear probing', () => {
+			const hashTableLinearProbing = new HashTableLinearProbing({
+				first: 1,
+				second: 2,
+			});
+			hashTableLinearProbing.remove('third');
+
+			expect(hashTableLinearProbing.data).toEqual({
+				36: new HashTableLinearProbingElement('second', 2),
+				52: new HashTableLinearProbingElement('first', 1),
+			});
+			expect(hashTableLinearProbing.size).toBe(2);
+		});
+
+		it('Should return null if the key is not in the hash table linear probing', () => {
+			const hashTableLinearProbing = new HashTableLinearProbing({
+				first: 1,
+				second: 2,
+			});
+			const returned = hashTableLinearProbing.remove('third');
+
+			expect(returned).toBeNull();
+		});
+
+		it('Should move all the subsequent elements that have the same hash code to the left', () => {
+			const hashTableLinearProbing = new HashTableLinearProbing({
+				first: 1,
+				tsrif: -1,
+				irstf: -2,
+				srift: -3,
+			});
+			hashTableLinearProbing.remove('tsrif');
+
+			expect(hashTableLinearProbing.data).toEqual({
+				52: new HashTableLinearProbingElement('first', 1),
+				53: new HashTableLinearProbingElement('irstf', -2),
+				54: new HashTableLinearProbingElement('srift', -3),
+			});
+			expect(hashTableLinearProbing.size).toBe(3);
+		});
+
+		it('Should move all the subsequent elements that have the same hash code to the left when remove the first position', () => {
+			const hashTableLinearProbing = new HashTableLinearProbing({
+				first: 1,
+				tsrif: 0,
+				irstf: -1,
+			}, {
+				maxSize: 3,
+			});
+			hashTableLinearProbing.remove('first');
+
+			expect(hashTableLinearProbing.data).toEqual({
+				0: new HashTableLinearProbingElement('tsrif', 0),
+				1: new HashTableLinearProbingElement('irstf', -1),
+			});
+			expect(hashTableLinearProbing.size).toBe(2);
+		});
+
+		it('Should move all the subsequent elements that have the same hash code to the left when remove a middle position', () => {
+			const hashTableLinearProbing = new HashTableLinearProbing({
+				third: 3,
+				driht: -3,
+				rihtd: 0,
+			}, {
+				maxSize: 3,
+			});
+			hashTableLinearProbing.remove('third');
+
+			expect(hashTableLinearProbing.data).toEqual({
+				0: new HashTableLinearProbingElement('rihtd', 0),
+				2: new HashTableLinearProbingElement('driht', -3),
+			});
+			expect(hashTableLinearProbing.size).toBe(2);
+		});
+	});
+
+	describe('Conversion to primitive', () => {
+		it('Should return the elements separated by comma in string conversion', () => {
+			const hashTableLinearProbing = new HashTableLinearProbing({
+				first: 1,
+				second: 2,
+				third: 3,
+			});
+			const string = String(hashTableLinearProbing);
+
+			expect(string).toBe('[ { second => 2 }, { third => 3 }, { first => 1 } ]');
+		});
+
+		it('Should return the size in number conversion', () => {
+			const hashTableLinearProbing = new HashTableLinearProbing({
+				first: 1,
+				second: 2,
+				third: 3,
+			});
+			const number = Number(hashTableLinearProbing);
+
+			expect(number).toBe(3);
+		});
+	});
+});

package/src/HashTableLinearProbing/index.ts

@@ -0,0 +1,128 @@
+import HashTableLinearProbingElement from './HashTableLinearProbingElement';
+import IHashTableLinearProbing from './IHashTableLinearProbing';
+import IHashTableLinearProbingInputs from './IHashTableLinearProbingInputs';
+import IHashTableLinearProbingOptions from './IHashTableLinearProbingOptions';
+
+export default class HashTableLinearProbing<T = number> implements IHashTableLinearProbing<T> {
+	private _maxSize: number = 0;
+	private _data: HashTableLinearProbingElement<T>[] = [];
+
+	constructor(
+		inputs: IHashTableLinearProbingInputs<T> = {},
+		{maxSize = 100}: IHashTableLinearProbingOptions = {maxSize: 100},
+	) {
+		this._maxSize = maxSize;
+
+		for (const [key, value] of Object.entries(inputs)) {
+			this.put(key, value);
+		}
+	}
+
+	get data(): { [index: number]: HashTableLinearProbingElement<T>; } {
+		return this._data
+			.map((value, index) => ({index, value}))
+			.reduce((accumulator, current) => ({
+				...accumulator,
+				[current.index]: current.value,
+			}), {});
+	}
+
+	get size(): number {
+		return Reflect.ownKeys(this.data).length;
+	}
+
+	public put(key: string, value: T): T | null {
+		if (this.size === this._maxSize) {
+			return null;
+		}
+
+		const element = new HashTableLinearProbingElement(key, value);
+		let position = this._hashCode(key);
+
+		if (this._data[position]) {
+			do {
+				position = this._nextPositionOf(position);
+			} while (this._data[position]);
+		}
+
+		this._data[position] = element;
+
+		return value;
+	}
+
+	public get(key: string): T | null {
+		const position = this._hashCode(key);
+		let i = position;
+
+		do {
+			if (this._data[i]?.key === key) {
+				return this._data[i].value;
+			}
+
+			i = this._nextPositionOf(i);
+		} while (this._data[i] && i !== position);
+
+		return null;
+	}
+
+	public remove(key: string): T | null {
+		if (this.get(key)) {
+			let position = this._hashCode(key);
+
+			while (this._data[position].key !== key) {
+				position = this._nextPositionOf(position);
+			}
+
+			const {value} = this._data[position];
+			Reflect.deleteProperty(this._data, position);
+
+			let i: number;
+			for (
+				i = position;
+				this._data[this._nextPositionOf(i)]
+					&& this._hashCode(this._data[this._nextPositionOf(i)].key) === this._hashCode(key)
+					&& this._nextPositionOf(i) !== position;
+				i = this._nextPositionOf(i)
+			) {
+				this._data[i] = this._data[this._nextPositionOf(i)];
+			}
+
+			if (i !== position) {
+				Reflect.deleteProperty(this._data, i);
+			}
+
+			return value;
+		}
+
+		return 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 _nextPositionOf(position: number) {
+		return (position + 1) % this._maxSize;
+	}
+
+	private _previousPositionOf(position: number) {
+		return (position + this.size - 1) % this._maxSize;
+	}
+
+	private [Symbol.toPrimitive](type: string): string | number | null {
+		if (type === 'string') {
+			return `[ ${Object.values(this.data).join(', ')} ]`;
+		}
+
+		if (type === 'number') {
+			return this.size;
+		}
+
+		return null;
+	}
+}

package/src/HashTableSeparateChaining/HashTableSeparateChainingElement.ts

@@ -0,0 +1,21 @@
+/* eslint-disable no-useless-constructor */
+/* eslint-disable no-unused-vars */
+
+export default class HashTableSeparateChainingElement<T> {
+	constructor(
+		public key: string,
+		public value: T,
+	) {}
+
+	private[Symbol.toPrimitive](type: string): string | number | null {
+		if (type === 'string') {
+			return `{ ${this.key} => ${this.value}}`;
+		}
+
+		if (type === 'number') {
+			return 2;
+		}
+
+		return null;
+	}
+}

package/src/HashTableSeparateChaining/IHashTableSeparateChaining.ts

@@ -0,0 +1,12 @@
+import HashTableSeparateChainingElement from './HashTableSeparateChainingElement';
+import IHashTableSeparateChainingData from './IHashTableSeparateChainingData';
+
+interface IHashTableSeparateChaining<T> {
+  get data(): IHashTableSeparateChainingData<T>;
+  get size(): number;
+  put(_key: string, _value: T): T;
+  get(_key: string): HashTableSeparateChainingElement<T> | null;
+  remove(_key: string): HashTableSeparateChainingElement<T> | null;
+}
+
+export default IHashTableSeparateChaining;

package/src/HashTableSeparateChaining/IHashTableSeparateChainingData.ts

@@ -0,0 +1,7 @@
+import LinkedList from '../LinkedList';
+
+interface IHashTableSeparateChainingData<T> {
+  [key: number]: LinkedList<T>;
+}
+
+export default IHashTableSeparateChainingData;

package/src/HashTableSeparateChaining/IHashTableSeparateChainingInputs.ts

@@ -0,0 +1,5 @@
+interface IHashTableSeparateChainingInputs<T> {
+  [key: string]: T;
+}
+
+export default IHashTableSeparateChainingInputs;

package/src/HashTableSeparateChaining/IHashTableSeparateChainingOptions.ts

@@ -0,0 +1,5 @@
+interface IHashTableSeparateChainingOptions {
+	maxSize: number;
+}
+
+export default IHashTableSeparateChainingOptions;