@gabrielrufino/cerebrum 1.1.0 → 1.2.0

package/dist/Math/Factorial.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Factorial = void 0;
+class Factorial {
+    constructor(n) {
+        this.n = n;
+        if (n < 0)
+            throw new RangeError('Input should be a non-negative integer');
+    }
+    execute() {
+        if ([0, 1].includes(this.n))
+            return 1;
+        return this.n * new Factorial(this.n - 1).execute();
+    }
+}
+exports.Factorial = Factorial;

package/dist/Math/Fibonacci.js

@@ -1,6 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Fibonacci = void 0;
+/**
+ * @complexity O(2^n)
+ */
 class Fibonacci {
     constructor(n) {
         this.n = n;

package/dist/Search/BinarySearch.js

@@ -2,6 +2,9 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.BinarySearch = void 0;
 const Search_1 = require("./Search");
+/**
+ * @complexity O(log n)
+ */
 class BinarySearch extends Search_1.Search {
     execute() {
         this.beforeExecute();

package/dist/Search/BinarySearch.test.js

@@ -2,50 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 const vitest_1 = require("vitest");
 const BinarySearch_1 = require("./BinarySearch");
+const Search_test_1 = require("./Search.test");
 (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();
-    });
+    Search_test_1.SearchTestsSuite.execute(BinarySearch_1.BinarySearch);
 });

package/dist/Search/LinearSearch.js

@@ -2,6 +2,9 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.LinearSearch = void 0;
 const Search_1 = require("./Search");
+/**
+ * @complexity O(n)
+ */
 class LinearSearch extends Search_1.Search {
     execute() {
         this.beforeExecute();

package/dist/Search/LinearSearch.test.js

@@ -2,34 +2,13 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 const vitest_1 = require("vitest");
 const LinearSearch_1 = require("./LinearSearch");
+const Search_test_1 = require("./Search.test");
 (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');
-    });
+    Search_test_1.SearchTestsSuite.execute(LinearSearch_1.LinearSearch);
     (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)
+            .setElements([1, 0, 3, 4, 5])
+            .setTarget(0)
             .execute();
         (0, vitest_1.expect)(result).toBe(1);
     });

package/dist/Search/Search.test.js

@@ -0,0 +1,60 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SearchTestsSuite = void 0;
+const vitest_1 = require("vitest");
+const Search_1 = require("./Search");
+(0, vitest_1.describe)('Search', () => {
+    (0, vitest_1.it)('should be defined', () => {
+        (0, vitest_1.expect)(Search_1.Search).toBeDefined();
+    });
+});
+class SearchTestsSuite {
+    static execute(Class) {
+        (0, vitest_1.it)('should return the index of the target when it exists in the array', () => {
+            const result = new Class()
+                .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 Class()
+                .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 Class()
+                .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 Class()
+                .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 Class()
+                .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 Class()
+                .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 Class()
+                .setElements([10, 20, 30, 40, 50])
+                .setTarget(60)
+                .execute();
+            (0, vitest_1.expect)(result).toBeNull();
+        });
+    }
+}
+exports.SearchTestsSuite = SearchTestsSuite;

package/dist/Sort/BubbleSort.js

@@ -1,10 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.BubbleSort = void 0;
-class BubbleSort {
-    constructor(numbers) {
-        this.numbers = numbers;
-    }
+const Sort_1 = require("./Sort");
+/**
+ * @complexity O(n^2)
+ */
+class BubbleSort extends Sort_1.Sort {
     execute() {
         for (let i = 0; i < this.numbers.length - 1; i++) {
             for (let j = 0; j < this.numbers.length - i - 1; j++) {

package/dist/Sort/QuickSort.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.QuickSort = void 0;
+const Sort_1 = require("./Sort");
+/**
+ * @complexity O(n log n)
+ */
+class QuickSort extends Sort_1.Sort {
+    execute() {
+        if (this.numbers.length <= 1) {
+            return [...this.numbers];
+        }
+        const pivotIndex = Math.floor(this.numbers.length / 2);
+        const left = [];
+        const right = [];
+        for (let i = 0; i < this.numbers.length; i++) {
+            if (i === pivotIndex) {
+                continue;
+            }
+            else if (this.numbers[i] <= this.numbers[pivotIndex]) {
+                left.push(this.numbers[i]);
+            }
+            else {
+                right.push(this.numbers[i]);
+            }
+        }
+        return [...new QuickSort(left).execute(), this.numbers[pivotIndex], ...new QuickSort(right).execute()];
+    }
+}
+exports.QuickSort = QuickSort;

package/dist/Sort/SelectionSort.js

@@ -1,10 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.SelectionSort = void 0;
-class SelectionSort {
-    constructor(numbers) {
-        this.numbers = numbers;
-    }
+const Sort_1 = require("./Sort");
+/**
+ * @complexity O(n^2)
+ */
+class SelectionSort extends Sort_1.Sort {
     execute() {
         for (let i = 0; i < this.numbers.length - 1; i++) {
             let minIndex = i;

package/dist/Sort/Sort.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Sort = void 0;
+class Sort {
+    constructor(numbers) {
+        this.numbers = numbers;
+    }
+}
+exports.Sort = Sort;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gabrielrufino/cerebrum",
-  "version": "1.1.0",
+  "version": "1.2.0",
   "description": "Algorithms made in TypeScript",
   "main": "dist/index.js",
   "type": "module",
@@ -19,7 +19,7 @@
     "@commitlint/config-conventional": "^19.5.0",
     "@faker-js/faker": "^8.4.1",
     "@gabrielrufino/eslint-config": "^1.6.0",
-    "@vitest/coverage-v8": "^2.1.3",
+    "@vitest/coverage-v8": "^2.1.4",
     "eslint": "^8.57.1",
     "husky": "^9.1.6",
     "typescript": "^5.6.3",

package/src/Math/Factorial.spec.ts

@@ -0,0 +1,34 @@
+import { describe, it, expect } from 'vitest';
+import { Factorial } from './Factorial';
+
+describe('Factorial', () => {
+  it('should return 1 when n is 0', () => {
+    expect(new Factorial(0).execute()).toBe(1);
+  });
+
+  it('should return 1 when n is 1', () => {
+    expect(new Factorial(1).execute()).toBe(1);
+  });
+
+  it('should return 2 when n is 2', () => {
+    expect(new Factorial(2).execute()).toBe(2);
+  });
+
+  it('should return 6 when n is 3', () => {
+    expect(new Factorial(3).execute()).toBe(6);
+  });
+
+  it('should return 24 when n is 4', () => {
+    expect(new Factorial(4).execute()).toBe(24);
+  });
+
+  it('should return 120 when n is 5', () => {
+    expect(new Factorial(5).execute()).toBe(120);
+  });
+
+  it('should throw an error when n is negative', () => {
+    expect(() => new Factorial(-1).execute()).toThrow(
+      'Input should be a non-negative integer'
+    );
+  });
+});

package/src/Math/Factorial.ts

@@ -0,0 +1,11 @@
+export class Factorial {
+  constructor (private readonly n: number) {
+    if (n < 0) throw new RangeError('Input should be a non-negative integer');
+  }
+
+  public execute (): number {
+    if ([0, 1].includes(this.n)) return 1
+
+    return this.n * new Factorial(this.n - 1).execute()
+  }
+}

package/src/Math/Fibonacci.ts

@@ -1,3 +1,6 @@
+/**
+ * @complexity O(2^n)
+ */
 export class Fibonacci {
   constructor (private readonly n: number) {
     if (n < 1) throw new RangeError('Input should be a positive integer');

package/src/Search/BinarySearch.test.ts

@@ -1,63 +1,7 @@
-import { describe, it, expect } from 'vitest'
+import { describe } from 'vitest'
 import { BinarySearch } from './BinarySearch'
+import { SearchTestsSuite } from './Search.test'
 
 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()
-  })
+  SearchTestsSuite.execute(BinarySearch)
 })

package/src/Search/BinarySearch.ts

@@ -1,5 +1,8 @@
 import { Search } from './Search';
 
+/**
+ * @complexity O(log n)
+ */
 export class BinarySearch extends Search {
   public execute(): number | null {
     this.beforeExecute()

package/src/Search/LinearSearch.test.ts

@@ -1,42 +1,14 @@
-import { describe, it, expect } from 'vitest'
+import { describe, expect, it } from 'vitest'
 import { LinearSearch } from './LinearSearch'
+import { SearchTestsSuite } from './Search.test'
 
 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')
-  })
+  SearchTestsSuite.execute(LinearSearch)
 
   it('should return the index when target is 0', () => {
     const result = new LinearSearch()
-      .setElements([1, 0, 3, 4, 5]).setTarget(0)
+      .setElements([1, 0, 3, 4, 5])
+      .setTarget(0)
       .execute()
 
     expect(result).toBe(1)

package/src/Search/LinearSearch.ts

@@ -1,5 +1,8 @@
 import { Search } from './Search'
 
+/**
+ * @complexity O(n)
+ */
 export class LinearSearch extends Search {
   public execute (): number | null {
     this.beforeExecute()

package/src/Search/Search.test.ts

@@ -0,0 +1,72 @@
+import { describe, expect, it } from 'vitest'
+
+import { Search } from './Search'
+
+describe('Search', () => {
+  it('should be defined', () => {
+    expect(Search).toBeDefined()
+  })
+})
+
+export class SearchTestsSuite {
+  static execute(Class: { new (elements?: Array<number>, target?: number): Search }) {
+    it('should return the index of the target when it exists in the array', () => {
+        const result = new Class()
+          .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 Class()
+          .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 Class()
+          .setTarget(3)
+    
+        expect(() => search.execute()).toThrow('Elements should be defined')
+      })
+    
+      it('should throw an error if target is not defined', () => {
+        const search = new Class()
+          .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 Class()
+          .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 Class()
+          .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 Class()
+          .setElements([10, 20, 30, 40, 50])
+          .setTarget(60)
+          .execute()
+    
+        expect(result).toBeNull()
+      })
+  }
+}

package/src/Sort/BubbleSort.spec.ts

@@ -1,40 +1,7 @@
-import { describe, it, expect } from 'vitest';
+import { describe } from 'vitest';
 import { BubbleSort } from './BubbleSort';
+import { SortTestsSuite } from './Sort.spec';
 
 describe('BubbleSort', () => {
-  it('should sort an unsorted array', () => {
-    const numbers = [64, 34, 25, 12, 22, 11, 90];
-    const sorted = new BubbleSort(numbers).execute();
-    expect(sorted).toEqual([11, 12, 22, 25, 34, 64, 90]);
-  });
-
-  it('should return the same array if already sorted', () => {
-    const numbers = [1, 2, 3, 4, 5];
-    const sorted = new BubbleSort(numbers).execute();
-    expect(sorted).toEqual([1, 2, 3, 4, 5]);
-  });
-
-  it('should sort an array with duplicate numbers', () => {
-    const numbers = [5, 1, 4, 2, 1];
-    const sorted = new BubbleSort(numbers).execute();
-    expect(sorted).toEqual([1, 1, 2, 4, 5]);
-  });
-
-  it('should handle an empty array', () => {
-    const numbers: number[] = [];
-    const sorted = new BubbleSort(numbers).execute();
-    expect(sorted).toEqual([]);
-  });
-
-  it('should handle an array with a single element', () => {
-    const numbers = [42];
-    const sorted = new BubbleSort(numbers).execute();
-    expect(sorted).toEqual([42]);
-  });
-
-  it('should sort an array with negative numbers', () => {
-    const numbers = [-3, -1, -4, 2, 0];
-    const sorted = new BubbleSort(numbers).execute();
-    expect(sorted).toEqual([-4, -3, -1, 0, 2]);
-  });
+  SortTestsSuite.execute(BubbleSort)
 });

package/src/Sort/BubbleSort.ts

@@ -1,8 +1,9 @@
-export class BubbleSort {
-  constructor (
-    private readonly numbers: Array<number>
-  ) {}
+import { Sort } from './Sort';
 
+/**
+ * @complexity O(n^2)
+ */
+export class BubbleSort extends Sort {
   public execute(): Array<number> {
     for (let i = 0; i < this.numbers.length - 1; i++) {
       for (let j = 0; j < this.numbers.length - i - 1; j++) {

package/src/Sort/QuickSort.spec.ts

@@ -0,0 +1,7 @@
+import { describe } from 'vitest';
+import { QuickSort } from './QuickSort';
+import { SortTestsSuite } from './Sort.spec';
+
+describe('QuickSort', () => {
+  SortTestsSuite.execute(QuickSort)
+});

package/src/Sort/QuickSort.ts

@@ -0,0 +1,28 @@
+import { Sort } from './Sort';
+
+/**
+ * @complexity O(n log n)
+ */
+export class QuickSort extends Sort {
+  public execute(): Array<number> {
+    if (this.numbers.length <= 1) {
+      return [...this.numbers]
+    }
+
+    const pivotIndex = Math.floor(this.numbers.length / 2);
+    const left: number[] = []
+    const right: number[] = []
+
+    for (let i = 0; i < this.numbers.length; i++) {
+      if (i === pivotIndex) {
+        continue
+      } else if (this.numbers[i] <= this.numbers[pivotIndex]) {
+        left.push(this.numbers[i])
+      } else {
+        right.push(this.numbers[i])
+      }
+    }
+
+    return [...new QuickSort(left).execute(), this.numbers[pivotIndex], ...new QuickSort(right).execute()]
+  }
+}

package/src/Sort/SelectionSort.spec.ts

@@ -1,36 +1,7 @@
-import { describe, it, expect } from 'vitest';
+import { describe } from 'vitest';
 import { SelectionSort } from './SelectionSort';
+import { SortTestsSuite } from './Sort.spec';
 
 describe('SelectionSort', () => {
-  it('should sort an array of numbers in ascending order', () => {
-    const unsorted = [64, 25, 12, 22, 11];
-    const sorted = [11, 12, 22, 25, 64];
-    expect(new SelectionSort(unsorted).execute()).toEqual(sorted);
-  });
-
-  it('should handle an empty array', () => {
-    const unsorted: number[] = [];
-    expect(new SelectionSort(unsorted).execute()).toEqual([]);
-  });
-
-  it('should handle an array with one element', () => {
-    const unsorted = [42];
-    expect(new SelectionSort(unsorted).execute()).toEqual([42]);
-  });
-
-  it('should handle an array with already sorted elements', () => {
-    const unsorted = [1, 2, 3, 4, 5];
-    expect(new SelectionSort(unsorted).execute()).toEqual([1, 2, 3, 4, 5]);
-  });
-
-  it('should handle an array with identical elements', () => {
-    const unsorted = [5, 5, 5, 5, 5];
-    expect(new SelectionSort(unsorted).execute()).toEqual([5, 5, 5, 5, 5]);
-  });
-
-  it('should sort an array with negative numbers', () => {
-    const unsorted = [3, -1, -5, 2, 0];
-    const sorted = [-5, -1, 0, 2, 3];
-    expect(new SelectionSort(unsorted).execute()).toEqual(sorted);
-  });
+  SortTestsSuite.execute(SelectionSort)
 });

package/src/Sort/SelectionSort.ts

@@ -1,8 +1,9 @@
-export class SelectionSort {
-  constructor(
-    private readonly numbers: Array<number>
-  ) {}
+import { Sort } from './Sort';
 
+/**
+ * @complexity O(n^2)
+ */
+export class SelectionSort extends Sort {
   public execute(): Array<number> {
     for (let i = 0; i < this.numbers.length - 1; i++) {
       let minIndex = i;

package/src/Sort/Sort.spec.ts

@@ -0,0 +1,45 @@
+import { describe, expect, it } from 'vitest'
+
+import { Sort } from './Sort'
+
+describe('Sort', () => {
+  it('should be defined', () => {
+    expect(Sort).toBeDefined()
+  })
+})
+
+export class SortTestsSuite {
+  static execute(Class: { new (numbers: Array<number>): Sort }) {
+    it('should sort an array of numbers in ascending order', () => {
+      const unsorted = [64, 25, 12, 22, 11];
+      const sorted = [11, 12, 22, 25, 64];
+      expect(new Class(unsorted).execute()).toEqual(sorted);
+    });
+  
+    it('should handle an empty array', () => {
+      const unsorted: number[] = [];
+      expect(new Class(unsorted).execute()).toEqual([]);
+    });
+  
+    it('should handle an array with one element', () => {
+      const unsorted = [42];
+      expect(new Class(unsorted).execute()).toEqual([42]);
+    });
+  
+    it('should handle an array with already sorted elements', () => {
+      const unsorted = [1, 2, 3, 4, 5];
+      expect(new Class(unsorted).execute()).toEqual([1, 2, 3, 4, 5]);
+    });
+  
+    it('should handle an array with identical elements', () => {
+      const unsorted = [5, 5, 5, 5, 5];
+      expect(new Class(unsorted).execute()).toEqual([5, 5, 5, 5, 5]);
+    });
+  
+    it('should sort an array with negative numbers', () => {
+      const unsorted = [3, -1, -5, 2, 0];
+      const sorted = [-5, -1, 0, 2, 3];
+      expect(new Class(unsorted).execute()).toEqual(sorted);
+    });
+  }
+}

package/src/Sort/Sort.ts

@@ -0,0 +1,7 @@
+export abstract class Sort {
+  constructor(
+    protected readonly numbers: Array<number>
+  ) {}
+
+  public abstract execute(): Array<number> 
+}