@gabrielrufino/cerebrum 1.0.1 → 1.1.0

package/.github/workflows/cd.yml

@@ -15,6 +15,6 @@ jobs:
     steps:
       - uses: gabrielrufino/check-ci@main
       - uses: actions/checkout@v4
-      - uses: gabrielrufino/node-pkg-cd@develop
+      - uses: gabrielrufino/node-pkg-cd@v1
         with:
           node-auth-token: ${{ secrets.NODE_AUTH_TOKEN }}

package/README.md

@@ -1 +1,3 @@
 # Cerebrum
+
+Algorithms made in TypeScript

package/dist/Math/LinearRegression.js

@@ -9,7 +9,6 @@ class LinearRegression {
         if (values.length === 0) {
             throw new Error('The input data must not be empty.');
         }
-        return this;
     }
     calculate() {
         const length = this.values.length;

package/dist/Search/BinarySearch.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BinarySearch = void 0;
+const Search_1 = require("./Search");
+class BinarySearch extends Search_1.Search {
+    execute() {
+        this.beforeExecute();
+        let left = 0;
+        let right = this.elements.length - 1;
+        while (left <= right) {
+            const middle = Math.floor((left + right) / 2);
+            const middleElement = this.elements[middle];
+            if (middleElement === this.target) {
+                return middle;
+            }
+            else if (middleElement < this.target) {
+                left = middle + 1;
+            }
+            else {
+                right = middle - 1;
+            }
+        }
+        return null;
+    }
+}
+exports.BinarySearch = BinarySearch;

package/dist/Search/BinarySearch.test.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const vitest_1 = require("vitest");
+const BinarySearch_1 = require("./BinarySearch");
+(0, vitest_1.describe)('BinarySearch', () => {
+    (0, vitest_1.it)('should return the index of the target when it exists in the array', () => {
+        const result = new BinarySearch_1.BinarySearch()
+            .setElements([1, 2, 3, 4, 5])
+            .setTarget(3)
+            .execute();
+        (0, vitest_1.expect)(result).toBe(2);
+    });
+    (0, vitest_1.it)('should return null when the target does not exist in the array', () => {
+        const result = new BinarySearch_1.BinarySearch()
+            .setElements([1, 2, 3, 4, 5])
+            .setTarget(6)
+            .execute();
+        (0, vitest_1.expect)(result).toBeNull();
+    });
+    (0, vitest_1.it)('should throw an error if elements are not defined', () => {
+        const search = new BinarySearch_1.BinarySearch()
+            .setTarget(3);
+        (0, vitest_1.expect)(() => search.execute()).toThrow('Elements should be defined');
+    });
+    (0, vitest_1.it)('should throw an error if target is not defined', () => {
+        const search = new BinarySearch_1.BinarySearch()
+            .setElements([1, 2, 3, 4, 5]);
+        (0, vitest_1.expect)(() => search.execute()).toThrow('Target should be defined');
+    });
+    (0, vitest_1.it)('should return the index when searching for 0 in a list that contains 0', () => {
+        const result = new BinarySearch_1.BinarySearch()
+            .setElements([0, 1, 2, 3, 4, 5])
+            .setTarget(0)
+            .execute();
+        (0, vitest_1.expect)(result).toBe(0);
+    });
+    (0, vitest_1.it)('should return null if target is smaller than all elements', () => {
+        const result = new BinarySearch_1.BinarySearch()
+            .setElements([10, 20, 30, 40, 50])
+            .setTarget(5)
+            .execute();
+        (0, vitest_1.expect)(result).toBeNull();
+    });
+    (0, vitest_1.it)('should return null if target is larger than all elements', () => {
+        const result = new BinarySearch_1.BinarySearch()
+            .setElements([10, 20, 30, 40, 50])
+            .setTarget(60)
+            .execute();
+        (0, vitest_1.expect)(result).toBeNull();
+    });
+});

package/dist/Search/LinearSearch.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LinearSearch = void 0;
+const Search_1 = require("./Search");
+class LinearSearch extends Search_1.Search {
+    execute() {
+        this.beforeExecute();
+        for (let i = 0; i < this.elements.length; i++) {
+            if (this.elements[i] === this.target) {
+                return i;
+            }
+        }
+        return null;
+    }
+}
+exports.LinearSearch = LinearSearch;

package/dist/Search/LinearSearch.test.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const vitest_1 = require("vitest");
+const LinearSearch_1 = require("./LinearSearch");
+(0, vitest_1.describe)('LinearSearch', () => {
+    (0, vitest_1.it)('should return the index of the target when it exists in the array', () => {
+        const result = new LinearSearch_1.LinearSearch()
+            .setElements([1, 2, 3, 4, 5])
+            .setTarget(3)
+            .execute();
+        (0, vitest_1.expect)(result).toBe(2);
+    });
+    (0, vitest_1.it)('should return null when the target does not exist in the array', () => {
+        const result = new LinearSearch_1.LinearSearch()
+            .setElements([1, 2, 3, 4, 5])
+            .setTarget(6)
+            .execute();
+        (0, vitest_1.expect)(result).toBeNull();
+    });
+    (0, vitest_1.it)('should throw an error if elements are not defined', () => {
+        const search = new LinearSearch_1.LinearSearch()
+            .setTarget(3);
+        (0, vitest_1.expect)(() => search.execute()).toThrow('Elements should be defined');
+    });
+    (0, vitest_1.it)('should throw an error if target is not defined', () => {
+        const search = new LinearSearch_1.LinearSearch()
+            .setElements([1, 2, 3, 4, 5]);
+        (0, vitest_1.expect)(() => search.execute()).toThrow('Target should be defined');
+    });
+    (0, vitest_1.it)('should return the index when target is 0', () => {
+        const result = new LinearSearch_1.LinearSearch()
+            .setElements([1, 0, 3, 4, 5]).setTarget(0)
+            .execute();
+        (0, vitest_1.expect)(result).toBe(1);
+    });
+});

package/dist/Search/Search.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Search = void 0;
+class Search {
+    constructor(elements, target) {
+        this.elements = elements;
+        this.target = target;
+    }
+    beforeExecute() {
+        if (!this.elements) {
+            throw new Error('Elements should be defined');
+        }
+        if (this.target === undefined || this.target === null) {
+            throw new Error('Target should be defined');
+        }
+    }
+    setElements(elements) {
+        this.elements = elements;
+        return this;
+    }
+    setTarget(target) {
+        this.target = target;
+        return this;
+    }
+}
+exports.Search = Search;

package/dist/Sort/BubbleSort.js

@@ -4,7 +4,6 @@ exports.BubbleSort = void 0;
 class BubbleSort {
     constructor(numbers) {
         this.numbers = numbers;
-        return this;
     }
     execute() {
         for (let i = 0; i < this.numbers.length - 1; i++) {

package/dist/Sort/SelectionSort.js

@@ -4,7 +4,6 @@ exports.SelectionSort = void 0;
 class SelectionSort {
     constructor(numbers) {
         this.numbers = numbers;
-        return this;
     }
     execute() {
         for (let i = 0; i < this.numbers.length - 1; i++) {

package/dist/index.js

@@ -15,5 +15,9 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./Math/Fibonacci"), exports);
+__exportStar(require("./Math/LinearRegression"), exports);
+__exportStar(require("./Math/TwoSum"), exports);
+__exportStar(require("./Search/BinarySearch"), exports);
+__exportStar(require("./Search/LinearSearch"), exports);
 __exportStar(require("./Sort/BubbleSort"), exports);
 __exportStar(require("./Sort/SelectionSort"), exports);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gabrielrufino/cerebrum",
-  "version": "1.0.1",
+  "version": "1.1.0",
   "description": "Algorithms made in TypeScript",
   "main": "dist/index.js",
   "type": "module",
@@ -10,8 +10,7 @@
     "lint:fix": "npm run lint -- --fix",
     "test": "vitest run",
     "test:cov": "npm test -- --coverage",
-    "test:watch": "vitest",
-    "prepare": "husky"
+    "test:watch": "vitest"
   },
   "author": "Gabriel Rufino <contato@gabrielrufino.com>",
   "license": "UNLICENSED",
@@ -20,10 +19,10 @@
     "@commitlint/config-conventional": "^19.5.0",
     "@faker-js/faker": "^8.4.1",
     "@gabrielrufino/eslint-config": "^1.6.0",
-    "@vitest/coverage-v8": "^2.1.1",
+    "@vitest/coverage-v8": "^2.1.3",
     "eslint": "^8.57.1",
     "husky": "^9.1.6",
-    "typescript": "^5.6.2",
+    "typescript": "^5.6.3",
     "vitest": "^2.1.0"
   },
   "funding": [

package/src/Math/LinearRegression.ts

@@ -6,8 +6,6 @@ export class LinearRegression {
     if (values.length === 0) {
       throw new Error('The input data must not be empty.');
     }
-
-    return this
   }
 
   public calculate () {

package/src/Search/BinarySearch.test.ts

@@ -0,0 +1,63 @@
+import { describe, it, expect } from 'vitest'
+import { BinarySearch } from './BinarySearch'
+
+describe('BinarySearch', () => {
+  it('should return the index of the target when it exists in the array', () => {
+    const result = new BinarySearch()
+      .setElements([1, 2, 3, 4, 5])
+      .setTarget(3)
+      .execute()
+
+    expect(result).toBe(2)
+  })
+
+  it('should return null when the target does not exist in the array', () => {
+    const result = new BinarySearch()
+      .setElements([1, 2, 3, 4, 5])
+      .setTarget(6)
+      .execute()
+
+    expect(result).toBeNull()
+  })
+
+  it('should throw an error if elements are not defined', () => {
+    const search = new BinarySearch()
+      .setTarget(3)
+
+    expect(() => search.execute()).toThrow('Elements should be defined')
+  })
+
+  it('should throw an error if target is not defined', () => {
+    const search = new BinarySearch()
+      .setElements([1, 2, 3, 4, 5])
+
+    expect(() => search.execute()).toThrow('Target should be defined')
+  })
+
+  it('should return the index when searching for 0 in a list that contains 0', () => {
+    const result = new BinarySearch()
+      .setElements([0, 1, 2, 3, 4, 5])
+      .setTarget(0)
+      .execute()
+
+    expect(result).toBe(0)
+  })
+
+  it('should return null if target is smaller than all elements', () => {
+    const result = new BinarySearch()
+      .setElements([10, 20, 30, 40, 50])
+      .setTarget(5)
+      .execute()
+
+    expect(result).toBeNull()
+  })
+
+  it('should return null if target is larger than all elements', () => {
+    const result = new BinarySearch()
+      .setElements([10, 20, 30, 40, 50])
+      .setTarget(60)
+      .execute()
+
+    expect(result).toBeNull()
+  })
+})

package/src/Search/BinarySearch.ts

@@ -0,0 +1,25 @@
+import { Search } from './Search';
+
+export class BinarySearch extends Search {
+  public execute(): number | null {
+    this.beforeExecute()
+
+    let left = 0
+    let right = this.elements!.length - 1
+
+    while (left <= right) {
+      const middle = Math.floor((left + right) / 2)
+      const middleElement = this.elements![middle]
+
+      if (middleElement === this.target!) {
+        return middle
+      } else if (middleElement < this.target!) {
+        left = middle + 1
+      } else {
+        right = middle - 1
+      }
+    }
+
+    return null
+  }
+}

package/src/Search/LinearSearch.test.ts

@@ -0,0 +1,44 @@
+import { describe, it, expect } from 'vitest'
+import { LinearSearch } from './LinearSearch'
+
+describe('LinearSearch', () => {
+  it('should return the index of the target when it exists in the array', () => {
+    const result = new LinearSearch()
+      .setElements([1, 2, 3, 4, 5])
+      .setTarget(3)
+      .execute()
+
+    expect(result).toBe(2)
+  })
+
+  it('should return null when the target does not exist in the array', () => {
+    const result = new LinearSearch()
+      .setElements([1, 2, 3, 4, 5])
+      .setTarget(6)
+      .execute()
+
+    expect(result).toBeNull()
+  })
+
+  it('should throw an error if elements are not defined', () => {
+    const search = new LinearSearch()
+      .setTarget(3)
+
+    expect(() => search.execute()).toThrow('Elements should be defined')
+  })
+
+  it('should throw an error if target is not defined', () => {
+    const search = new LinearSearch()
+      .setElements([1, 2, 3, 4, 5])
+
+    expect(() => search.execute()).toThrow('Target should be defined')
+  })
+
+  it('should return the index when target is 0', () => {
+    const result = new LinearSearch()
+      .setElements([1, 0, 3, 4, 5]).setTarget(0)
+      .execute()
+
+    expect(result).toBe(1)
+  })
+})

package/src/Search/LinearSearch.ts

@@ -0,0 +1,15 @@
+import { Search } from './Search'
+
+export class LinearSearch extends Search {
+  public execute (): number | null {
+    this.beforeExecute()
+
+    for (let i = 0; i < this.elements!.length; i++) {
+      if (this.elements![i] === this.target) {
+        return i
+      }
+    }
+
+    return null
+  }
+}

package/src/Search/Search.ts

@@ -0,0 +1,28 @@
+export abstract class Search {
+  constructor (
+    protected elements?: Array<number>,
+    protected target?: number
+  ) {}
+
+  protected beforeExecute () {
+    if (!this.elements) {
+      throw new Error('Elements should be defined')
+    }
+
+    if (this.target === undefined || this.target === null) {
+      throw new Error('Target should be defined')
+    }
+  }
+
+  public setElements (elements: Array<number>) {
+    this.elements = elements
+    return this
+  }
+
+  public setTarget (target: number) {
+    this.target = target
+    return this
+  }
+
+  public abstract execute(): number | null
+}

package/src/Sort/BubbleSort.ts

@@ -1,9 +1,7 @@
 export class BubbleSort {
   constructor (
     private readonly numbers: Array<number>
-  ) {
-    return this
-  }
+  ) {}
 
   public execute(): Array<number> {
     for (let i = 0; i < this.numbers.length - 1; i++) {

package/src/Sort/SelectionSort.ts

@@ -1,9 +1,7 @@
 export class SelectionSort {
   constructor(
     private readonly numbers: Array<number>
-  ) {
-    return this
-  }
+  ) {}
 
   public execute(): Array<number> {
     for (let i = 0; i < this.numbers.length - 1; i++) {

package/src/index.ts

@@ -1,4 +1,9 @@
 export * from './Math/Fibonacci';
+export * from './Math/LinearRegression';
+export * from './Math/TwoSum';
+
+export * from './Search/BinarySearch';
+export * from './Search/LinearSearch';
 
 export * from './Sort/BubbleSort';
 export * from './Sort/SelectionSort';