@gabrielrufino/cube 1.0.1

package/package.json

@@ -0,0 +1,42 @@
+{
+  "name": "@gabrielrufino/cube",
+  "version": "1.0.1",
+  "description": "Data Structures and Algorithms made in Typescript",
+  "main": "build/index.js",
+  "scripts": {
+    "lint": "eslint src/**/*.ts",
+    "test": "jest",
+    "test:cov": "npm t -- --coverage",
+    "test:watch": "npm t -- --watch",
+    "build": "rimraf ./build && tsc"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/gabrielrufino/cube.git"
+  },
+  "keywords": [
+    "Data",
+    "Structures",
+    "Algorithms"
+  ],
+  "author": "Gabriel Rufino <contato@gabrielrufino.com>",
+  "license": "UNLICENSED",
+  "bugs": {
+    "url": "https://github.com/gabrielrufino/cube/issues"
+  },
+  "homepage": "https://github.com/gabrielrufino/cube#readme",
+  "devDependencies": {
+    "@types/faker": "^5.5.9",
+    "@types/jest": "^27.4.0",
+    "@typescript-eslint/eslint-plugin": "^5.10.1",
+    "@typescript-eslint/parser": "^5.10.1",
+    "eslint": "^8.8.0",
+    "eslint-config-xo": "^0.39.0",
+    "faker": "^5.5.3",
+    "jest": "^27.4.7",
+    "rimraf": "^3.0.2",
+    "ts-jest": "^27.1.3",
+    "ts-node": "^10.4.0",
+    "typescript": "^4.5.5"
+  }
+}

package/src/Algorithms/index.spec.ts

@@ -0,0 +1,15 @@
+import {describe, it, expect} from '@jest/globals';
+
+import Algorithms from './';
+
+describe('Algorithms', () => {
+	describe('.decimalToBinary()', () => {
+		it('Should return the correct result', () => {
+			const n = 10;
+			const expected = '1010';
+
+			const result = Algorithms.decimalToBinary(n);
+			expect(result).toBe(expected);
+		});
+	});
+});

package/src/Algorithms/index.ts

@@ -0,0 +1,21 @@
+import {Stack} from '..';
+
+export default class Algorithms {
+	public static decimalToBinary(n: number) {
+		const stack = new Stack();
+
+		while (n > 0) {
+			const rem = Math.floor(n % 2);
+			stack.push(rem);
+			n = Math.floor(n / 2);
+		}
+
+		let binary = '';
+		while (!stack.isEmpty) {
+			// eslint-disable-next-line no-unsafe-optional-chaining
+			binary += stack.pop()?.toString();
+		}
+
+		return binary;
+	}
+}

package/src/Array/IArray.ts

@@ -0,0 +1,10 @@
+interface IArray<T> {
+	insertInLastPosition(_element: T): T;
+	insertInFirstPosition(_element: T): T;
+	insertInPosition(_position: number, _element: T): T;
+	removeFromLastPosition(): T | undefined;
+	removeFromFirstPosition(): T | undefined;
+	removeFromPosition(_position: number): T | undefined;
+}
+
+export default IArray;

package/src/Array/index.spec.ts

@@ -0,0 +1,151 @@
+import {describe, expect, it} from '@jest/globals';
+import faker from 'faker';
+
+import Array from './';
+
+describe('Array', () => {
+	it('Should create an empty array with no problems', () => {
+		const array = new Array();
+
+		expect(array.data).toEqual([]);
+		expect(array.size).toBe(0);
+	});
+
+	it('Should create a filled array with no problems', () => {
+		const array = new Array(1, 2, 3, 4, 5);
+
+		expect(array.data).toEqual([1, 2, 3, 4, 5]);
+		expect(array.size).toBe(5);
+	});
+
+	it('Should return the correct size of the array', () => {
+		const size = faker.datatype.number(200);
+		const params = [];
+
+		for (let i = 0; i < size; i++) {
+			params.push(faker.datatype.number());
+		}
+
+		const array = new Array(...params);
+
+		expect(array.size).toBe(size);
+	});
+
+	describe('.insertInLastPosition()', () => {
+		it('Should insert a new element in the last position', () => {
+			const array = new Array(1, 2, 3);
+			array.insertInLastPosition(4);
+
+			expect(array.data).toEqual([1, 2, 3, 4]);
+		});
+	});
+
+	describe('.insertInFirstPosition()', () => {
+		it('Should insert a new element in the first position', () => {
+			const array = new Array(2, 3, 4);
+			array.insertInFirstPosition(1);
+
+			expect(array.data).toEqual([1, 2, 3, 4]);
+		});
+
+		it('Should insert a new element in a arbitrary position of an array', () => {
+			const array = new Array(1, 2, 4);
+			array.insertInPosition(2, 3);
+
+			expect(array.data).toEqual([1, 2, 3, 4]);
+		});
+	});
+
+	describe('.removeFromLastPosition()', () => {
+		it('Should remove and return the last element of the array', () => {
+			const array = new Array(1, 2, 3, 4);
+			const element = array.removeFromLastPosition();
+
+			expect(array.data).toEqual([1, 2, 3]);
+			expect(element).toBe(4);
+		});
+
+		it('Should ruturn undefined when trying to remove the last element of an empty array', () => {
+			const array = new Array();
+			const element = array.removeFromLastPosition();
+
+			expect(array.data).toEqual([]);
+			expect(element).toBe(undefined);
+		});
+	});
+
+	describe('.removeFromFirstPosition()', () => {
+		it('Should remove and return the first element of the array', () => {
+			const array = new Array(1, 2, 3, 4);
+			const element = array.removeFromFirstPosition();
+
+			expect(array.data).toEqual([2, 3, 4]);
+			expect(element).toBe(1);
+		});
+
+		it('Should ruturn undefined when trying to remove the first element of an empty array', () => {
+			const array = new Array();
+			const element = array.removeFromFirstPosition();
+
+			expect(array.data).toEqual([]);
+			expect(element).toBe(undefined);
+		});
+	});
+
+	describe('.removeFromPosition()', () => {
+		it('Should remove and return the element of an arbitrary position from array', () => {
+			const array = new Array(1, 2, 3, 4);
+			const element = array.removeFromPosition(2);
+
+			expect(array.data).toEqual([1, 2, 4]);
+			expect(element).toBe(3);
+		});
+
+		it('Should return return when trying to remove the element of an arbitrary position from an empty array', () => {
+			const array = new Array();
+			const element = array.removeFromPosition(faker.datatype.number());
+
+			expect(array.data).toEqual([]);
+			expect(element).toBe(undefined);
+		});
+	});
+
+	describe('Bidimensional array', () => {
+		it('Should create an bidimensional array with no problems', () => {
+			const array = new Array<Array>(
+				new Array(1, 2, 3),
+				new Array(4, 5, 6),
+				new Array(7, 8, 9),
+			);
+
+			expect(array.data).toEqual([
+				new Array(1, 2, 3),
+				new Array(4, 5, 6),
+				new Array(7, 8, 9),
+			]);
+			expect(array.data[0].data).toEqual([1, 2, 3]);
+			expect(array.data[1].data).toEqual([4, 5, 6]);
+			expect(array.data[2].data).toEqual([7, 8, 9]);
+			expect(array.size).toBe(3);
+			expect(array.data[0].size).toEqual(3);
+			expect(array.data[1].size).toEqual(3);
+			expect(array.data[2].size).toEqual(3);
+		});
+	});
+
+	describe('Conversion to primitive', () => {
+		it('Should return the elements separated by comma in string conversion', () => {
+			const array = new Array(1, 2, 3, 4);
+			const string = String(array);
+
+			expect(string).toBe('1, 2, 3, 4');
+		});
+
+		it('Should return the array size in number conversion', () => {
+			const array = new Array(1, 2, 3, 4);
+			const number = Number(array);
+
+			expect(number).toBe(4);
+		});
+	});
+});

package/src/Array/index.ts

@@ -0,0 +1,68 @@
+import DataStructure from '../DataStructure';
+import IArray from './IArray';
+
+export default class Array<T = number> extends DataStructure<T> implements IArray<T> {
+	constructor(...inputs: T[]) {
+		super(inputs);
+	}
+
+	public insertInLastPosition(element: T): T {
+		this._data[this.size] = element;
+		return element;
+	}
+
+	public insertInFirstPosition(element: T): T {
+		for (let i = this.size; i > 0; i--) {
+			this._data[i] = this._data[i - 1];
+		}
+
+		this._data[0] = element;
+		return element;
+	}
+
+	public insertInPosition(position: number, element: T): T {
+		this._data.splice(position, 0, element);
+		return element;
+	}
+
+	public removeFromLastPosition(): T | undefined {
+		const element = this._data[this.size - 1];
+		const array = new Array<T>();
+
+		for (let i = 0; i < this.size - 1; i++) {
+			array.insertInLastPosition(this._data[i]);
+		}
+
+		this._data = array.data;
+		return element;
+	}
+
+	public removeFromFirstPosition(): T | undefined {
+		const element = this._data[0];
+		const array = new Array<T>();
+
+		for (let i = 0; i < this.size - 1; i++) {
+			array.insertInLastPosition(this._data[i + 1]);
+		}
+
+		this._data = array.data;
+		return element;
+	}
+
+	public removeFromPosition(position: number): T | undefined {
+		const [element] = this._data.splice(position, 1);
+		return element;
+	}
+
+	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/BinarySearchTree/BinarySearchTreeNode.spec.ts

@@ -0,0 +1,29 @@
+import {describe, it, expect} from '@jest/globals';
+import faker from 'faker';
+
+import BinarySearchTreeNode from './BinarySearchTreeNode';
+
+describe('BinarySearchTreeNode', () => {
+	it('Should create a node without problems', () => {
+		const number = faker.datatype.number();
+		const binarySearchTreeNode = new BinarySearchTreeNode<number>(number);
+
+		expect(binarySearchTreeNode.value).toBe(number);
+		expect(binarySearchTreeNode.left).toBeNull();
+		expect(binarySearchTreeNode.right).toBeNull();
+	});
+
+	describe('Conversion to primitive', () => {
+		it('Should return the value poiting to left and right nodes in string conversion', () => {
+			const rootNumber = faker.datatype.number();
+			const leftNumber = faker.datatype.number();
+			const rightNumber = faker.datatype.number();
+			const node = new BinarySearchTreeNode(rootNumber);
+			node.left = new BinarySearchTreeNode(leftNumber);
+			node.right = new BinarySearchTreeNode(rightNumber);
+			const string = String(node);
+
+			expect(string).toBe(`[[null] <= (${leftNumber}) => [null]] <= (${rootNumber}) => [[null] <= (${rightNumber}) => [null]]`);
+		});
+	});
+});

package/src/BinarySearchTree/BinarySearchTreeNode.ts

@@ -0,0 +1,23 @@
+export default class BinarySearchTreeNode<T> {
+	public value: T;
+	public left: BinarySearchTreeNode<T> | null = null;
+	public right: BinarySearchTreeNode<T> | null = null;
+
+	constructor(value: T) {
+		this.value = value;
+		this.left = null;
+		this.right = null;
+	}
+
+	[Symbol.toPrimitive](type: string): string | number | null {
+		if (type === 'string') {
+			return `[${this.left}] <= (${this.value}) => [${this.right}]`;
+		}
+
+		if (type === 'number') {
+			return 1 + (this.left ? 1 : 0) + (this.right ? 1 : 0);
+		}
+
+		return null;
+	}
+}

package/src/BinarySearchTree/IBinarySearchNodeOptions.ts

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

package/src/BinarySearchTree/IBinarySearchTree.ts

@@ -0,0 +1,16 @@
+import IBinarySearchTreeData from './IBinarySearchTreeData';
+
+interface IBinarySearchTree<T> {
+	get data(): IBinarySearchTreeData<T>;
+	get size(): number;
+	get min(): T | null;
+	get max(): T | null;
+	insert(_value: T): T;
+	walkInOrder(_callback: (_value: T) => any): void;
+	walkPreOrder(_callback: (_value: T) => any): void;
+	walkPostOrder(_callback: (_value: T) => any): void;
+	search(_value: T): boolean;
+	remove(_value: T): T | null;
+}
+
+export default IBinarySearchTree;

package/src/BinarySearchTree/IBinarySearchTreeData.ts

@@ -0,0 +1,9 @@
+import BinarySearchTreeNode from './BinarySearchTreeNode';
+
+interface IBinarySearchTreeData<T> {
+	left: BinarySearchTreeNode<T> | null;
+	value: T | null;
+	right: BinarySearchTreeNode<T> | null;
+}
+
+export default IBinarySearchTreeData;