@gabrielrufino/cube 1.0.1 → 1.0.6

package/src/HashTable/index.ts

@@ -1,78 +0,0 @@
-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

@@ -1,28 +0,0 @@
-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

@@ -1,18 +0,0 @@
-/* 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

@@ -1,11 +0,0 @@
-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

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

package/src/HashTableLinearProbing/IHashTableLinearProbingInputs.ts

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

package/src/HashTableLinearProbing/IHashTableLinearProbingOptions.ts

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

package/src/HashTableLinearProbing/index.spec.ts

@@ -1,266 +0,0 @@
-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

@@ -1,128 +0,0 @@
-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

@@ -1,21 +0,0 @@
-/* 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

@@ -1,12 +0,0 @@
-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

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

package/src/HashTableSeparateChaining/IHashTableSeparateChainingInputs.ts

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

package/src/HashTableSeparateChaining/IHashTableSeparateChainingOptions.ts

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