Merge pull request #57 from monkey0722/feature/settings

monkey0722 · web-flow · commit 2fe6f34bef36 · 2024-12-28T21:51:01.000+09:00
Update project configuration and improve code quality across data structures
diff --git a/.prettierrc b/.prettierrc
@@ -1,5 +1,15 @@
 {
+  "printWidth": 100,
+  "tabWidth": 2,
+  "useTabs": false,
+  "semi": true,
   "singleQuote": true,
+  "quoteProps": "as-needed",
+  "trailingComma": "all",
   "bracketSpacing": false,
-  "trailingComma": "es5"
+  "bracketSameLine": false,
+  "arrowParens": "always",
+  "endOfLine": "lf",
+  "embeddedLanguageFormatting": "auto",
+  "singleAttributePerLine": false
 }
diff --git a/algorithms/dp/knapsack.test.ts b/algorithms/dp/knapsack.test.ts
@@ -52,7 +52,7 @@ describe('Knapsack', () => {
       ];
       const capacity = 5;
       expect(() => Knapsack.solve(items, capacity)).toThrowError(
-        'Item weights and values must be non-negative'
+        'Item weights and values must be non-negative',
       );
     });
   });
@@ -95,7 +95,7 @@ describe('Knapsack', () => {
       ];
       const capacity = 15;
       expect(() => Knapsack.solveFractional(items, capacity)).toThrowError(
-        'Item weights and values must be non-negative'
+        'Item weights and values must be non-negative',
       );
     });
   });
diff --git a/algorithms/dp/knapsack.ts b/algorithms/dp/knapsack.ts
@@ -13,7 +13,7 @@ export class Knapsack {
    */
   static solve(
     items: Item[],
-    capacity: number
+    capacity: number,
   ): {
     maxValue: number;
     selectedItems: boolean[];
@@ -28,19 +28,14 @@ export class Knapsack {
     }
 
     const n = items.length;
-    const dp: number[][] = Array.from({length: n + 1}, () =>
-      Array(capacity + 1).fill(0)
-    );
+    const dp: number[][] = Array.from({length: n + 1}, () => Array(capacity + 1).fill(0));
 
     // Build the DP table
     for (let i = 1; i <= n; i++) {
       const item = items[i - 1];
       for (let w = 0; w <= capacity; w++) {
         if (item.weight <= w) {
-          dp[i][w] = Math.max(
-            dp[i - 1][w],
-            dp[i - 1][w - item.weight] + item.value
-          );
+          dp[i][w] = Math.max(dp[i - 1][w], dp[i - 1][w - item.weight] + item.value);
         } else {
           dp[i][w] = dp[i - 1][w];
         }
@@ -72,7 +67,7 @@ export class Knapsack {
    */
   static solveFractional(
     items: Item[],
-    capacity: number
+    capacity: number,
   ): {
     maxValue: number;
     fractions: number[];
diff --git a/algorithms/search/bellman-ford-search/bellmanFordSearch.test.ts b/algorithms/search/bellman-ford-search/bellmanFordSearch.test.ts
@@ -35,13 +35,13 @@ describe('BellmanFord', () => {
       {source: 1, target: 2, weight: 3},
     ];
     expect(() => BellmanFord.findShortestPaths(0, edges, 0)).toThrowError(
-      'Number of vertices must be positive'
+      'Number of vertices must be positive',
     );
   });
   test('should throw error for invalid edge vertices', () => {
     const edges = [{source: 0, target: 5, weight: 4}];
     expect(() => BellmanFord.findShortestPaths(4, edges, 0)).toThrowError(
-      'Edge contains an invalid vertex'
+      'Edge contains an invalid vertex',
     );
   });
   test('should handle large graph with no negative weight cycles', () => {
diff --git a/algorithms/search/bellman-ford-search/bellmanFordSearch.ts b/algorithms/search/bellman-ford-search/bellmanFordSearch.ts
@@ -15,11 +15,7 @@ export class BellmanFord {
    * @returns {number[] | null} - An array of shortest distances to each vertex from the source, or `null` if a negative weight cycle exists.
    * @throws {Error} If the input parameters are invalid.
    */
-  static findShortestPaths(
-    vertices: number,
-    edges: Edge[],
-    source: number
-  ): number[] | null {
+  static findShortestPaths(vertices: number, edges: Edge[], source: number): number[] | null {
     // Validate input
     this.validateInput(vertices, edges, source);
 
@@ -62,7 +58,7 @@ export class BellmanFord {
     vertices: number,
     edges: Edge[],
     source: number,
-    target: number
+    target: number,
   ): number[] | null {
     // Validate input
     this.validateInput(vertices, edges, source);
@@ -131,11 +127,7 @@ export class BellmanFord {
    * @param {number} source - The starting vertex.
    * @throws {Error} If the input parameters are invalid.
    */
-  private static validateInput(
-    vertices: number,
-    edges: Edge[],
-    source: number
-  ): void {
+  private static validateInput(vertices: number, edges: Edge[], source: number): void {
     if (vertices <= 0) {
       throw new Error('Number of vertices must be positive');
     }
diff --git a/algorithms/search/interpolation-search/interpolationSearch.ts b/algorithms/search/interpolation-search/interpolationSearch.ts
@@ -1,12 +1,8 @@
-export function interpolationSearch(
-  arr: number[],
-  key: number
-): number | undefined {
+export function interpolationSearch(arr: number[], key: number): number | undefined {
   let low = 0;
   let high = arr.length - 1;
   while (low <= high && key >= arr[low] && key <= arr[high]) {
-    const pos =
-      low + ((high - low) / (arr[high] - arr[low])) * (key - arr[low]);
+    const pos = low + ((high - low) / (arr[high] - arr[low])) * (key - arr[low]);
     if (arr[Math.floor(pos)] === key) {
       return Math.floor(pos);
     }
diff --git a/algorithms/search/jump-search/jumpSearch.ts b/algorithms/search/jump-search/jumpSearch.ts
@@ -11,11 +11,11 @@ export function jumpSearch(arr: number[], x: number): number | undefined {
   }
   while (arr[prev] < x) {
     prev++;
-    if (prev == Math.min(step, n)) {
+    if (prev === Math.min(step, n)) {
       return undefined;
     }
   }
-  if (arr[prev] == x) {
+  if (arr[prev] === x) {
     return prev;
   }
   return undefined;
diff --git a/algorithms/search/linear-search/linearSearch.test.ts b/algorithms/search/linear-search/linearSearch.test.ts
@@ -1,15 +1,7 @@
 import {linearSearch} from './linearSearch';
 
 describe('linear-search', () => {
-  const colors = [
-    'red',
-    'orange',
-    'yellow',
-    'green',
-    'blue',
-    'indigo',
-    'violet',
-  ];
+  const colors = ['red', 'orange', 'yellow', 'green', 'blue', 'indigo', 'violet'];
 
   it('normal', () => {
     expect(linearSearch(colors, 'red')).toEqual(0);
diff --git a/algorithms/sorting/bubble-sort-counters/bubbleSortCounters.test.ts b/algorithms/sorting/bubble-sort-counters/bubbleSortCounters.test.ts
@@ -1,7 +1,4 @@
-import {
-  bubbleSortCountersBasic,
-  bubbleSortCounters,
-} from './bubbleSortCounters';
+import {bubbleSortCountersBasic, bubbleSortCounters} from './bubbleSortCounters';
 
 describe('bubble-sort-counters', () => {
   const randomArray = [9, 2, 5, 6, 4, 3, 7, 10, 1, 8];
diff --git a/algorithms/sorting/merge-sort-counters/mergeSortCounters.ts b/algorithms/sorting/merge-sort-counters/mergeSortCounters.ts
@@ -7,7 +7,7 @@ let countOuter = 0;
 let countInner = 0;
 let countSwap = 0;
 
-function resetCounters() {
+function resetCounters(): void {
   countOuter = 0;
   countInner = 0;
   countSwap = 0;
@@ -42,7 +42,7 @@ export function mergeSortCountersTopDown(items: number[]): number[] {
 
   return mergeCountersTopDown(
     mergeSortCountersTopDown(leftItems),
-    mergeSortCountersTopDown(rightItems)
+    mergeSortCountersTopDown(rightItems),
   );
 }
 
@@ -76,11 +76,7 @@ function mergeSortCountersBottomUp(items: number[]): number[] {
   return items;
 }
 
-function mergeCountersBottomUp(
-  items: number[],
-  left: number,
-  step: number
-): void {
+function mergeCountersBottomUp(items: number[], left: number, step: number): void {
   const tmp: number[] = [];
   const right: number = left + step;
   const last: number = Math.min(left + step * 2 - 1, items.length - 1);
@@ -89,10 +85,7 @@ function mergeCountersBottomUp(
   let moveRight: number = right;
 
   for (let i = left; i <= last; i++) {
-    if (
-      (items[moveLeft] <= items[moveRight] || moveRight > last) &&
-      moveLeft < right
-    ) {
+    if ((items[moveLeft] <= items[moveRight] || moveRight > last) && moveLeft < right) {
       tmp[i] = items[moveLeft];
       moveLeft++;
     } else {
diff --git a/algorithms/sorting/merge-sort/mergeSort.ts b/algorithms/sorting/merge-sort/mergeSort.ts
@@ -23,10 +23,7 @@ export function mergeSortTopDown(items: number[]): number[] {
   const leftItems = items.slice(0, middle);
   const rightItems = items.slice(middle);
 
-  return mergeTopDown(
-    mergeSortTopDown(leftItems),
-    mergeSortTopDown(rightItems)
-  );
+  return mergeTopDown(mergeSortTopDown(leftItems), mergeSortTopDown(rightItems));
 }
 
 /**
@@ -41,10 +38,7 @@ function mergeBottomUp(items: number[], left: number, step: number): void {
   let moveRight = right;
 
   for (let i = left; i <= last; i++) {
-    if (
-      (items[moveLeft] <= items[moveRight] || moveRight > last) &&
-      moveLeft < right
-    ) {
+    if ((items[moveLeft] <= items[moveRight] || moveRight > last) && moveLeft < right) {
       tmp[i] = items[moveLeft];
       moveLeft++;
     } else {
diff --git a/data-structures/binary-tree/binaryTree.ts b/data-structures/binary-tree/binaryTree.ts
@@ -10,7 +10,7 @@ export class BinaryTree<T> {
    * Inserts a new value into the binary search tree.
    * @param {T} value The value to insert.
    */
-  insert(value: T) {
+  insert(value: T): void {
     const newNode = new BinaryTreeNode(value);
     if (this.root === null) {
       this.root = newNode;
@@ -19,7 +19,7 @@ export class BinaryTree<T> {
     }
   }
 
-  private insertNode(node: BinaryTreeNode<T>, newNode: BinaryTreeNode<T>) {
+  private insertNode(node: BinaryTreeNode<T>, newNode: BinaryTreeNode<T>): void {
     if (newNode.value < node.value) {
       if (node.left === null) {
         node.left = newNode;
@@ -44,10 +44,7 @@ export class BinaryTree<T> {
     return this.search(this.root, value) !== null;
   }
 
-  private search(
-    node: BinaryTreeNode<T> | null,
-    value: T
-  ): BinaryTreeNode<T> | null {
+  private search(node: BinaryTreeNode<T> | null, value: T): BinaryTreeNode<T> | null {
     if (node === null) {
       return null;
     }
@@ -65,8 +62,8 @@ export class BinaryTree<T> {
    * Traverses the binary search tree in order (left, root, right).
    * @param {function} visit Function to call on each value.
    */
-  inOrderTraverse(visit: (value: T) => void) {
-    function traverse(node: BinaryTreeNode<T> | null) {
+  inOrderTraverse(visit: (value: T) => void): void {
+    function traverse(node: BinaryTreeNode<T> | null): void {
       if (node === null) return;
       traverse(node.left);
       visit(node.value);
@@ -79,14 +76,11 @@ export class BinaryTree<T> {
    * Removes a value from the binary search tree.
    * @param {T} value The value to remove.
    */
-  remove(value: T) {
+  remove(value: T): void {
     this.root = this.removeNode(this.root, value);
   }
 
-  private removeNode(
-    node: BinaryTreeNode<T> | null,
-    value: T
-  ): BinaryTreeNode<T> | null {
+  private removeNode(node: BinaryTreeNode<T> | null, value: T): BinaryTreeNode<T> | null {
     if (node === null) {
       return null;
     }
diff --git a/data-structures/hash-table/hashTable.test.ts b/data-structures/hash-table/hashTable.test.ts
@@ -80,8 +80,6 @@ describe('HashTable with large data set', () => {
       hashTable.set(i, i);
     }
     const endTime = performance.now();
-    console.log(
-      `Inserting ${largeSize} items took ${endTime - startTime} milliseconds`
-    );
+    console.log(`Inserting ${largeSize} items took ${endTime - startTime} milliseconds`);
   });
 });
diff --git a/data-structures/heap/minHeap.ts b/data-structures/heap/minHeap.ts
@@ -25,7 +25,6 @@ export class MinHeap<T> {
    * @param {number} parentIndex The index of the parent node.
    * @return {number} The index of the right child.
    */
-  priva;
   private getRightChildIndex(parentIndex: number): number {
     return 2 * parentIndex + 2;
   }
@@ -45,10 +44,7 @@ export class MinHeap<T> {
    * @param {number} index2 The index of the second element.
    */
   private swap(index1: number, index2: number): void {
-    [this.heap[index1], this.heap[index2]] = [
-      this.heap[index2],
-      this.heap[index1],
-    ];
+    [this.heap[index1], this.heap[index2]] = [this.heap[index2], this.heap[index1]];
   }
 
   /**
@@ -58,8 +54,7 @@ export class MinHeap<T> {
     let index = this.heap.length - 1;
     while (
       index > 0 &&
-      this.compareFn(this.heap[this.getParentIndex(index)], this.heap[index]) >
-        0
+      this.compareFn(this.heap[this.getParentIndex(index)], this.heap[index]) > 0
     ) {
       const parentIndex = this.getParentIndex(index);
       this.swap(index, parentIndex);
@@ -81,10 +76,7 @@ export class MinHeap<T> {
       const rightChildIndex = this.getRightChildIndex(index);
       if (
         rightChildIndex < this.heap.length &&
-        this.compareFn(
-          this.heap[rightChildIndex],
-          this.heap[smallerChildIndex]
-        ) < 0
+        this.compareFn(this.heap[rightChildIndex], this.heap[smallerChildIndex]) < 0
       ) {
         smallerChildIndex = rightChildIndex;
       }
diff --git a/data-structures/red-black-tree/redBlackTree.ts b/data-structures/red-black-tree/redBlackTree.ts
@@ -43,10 +43,7 @@ export class RedBlackTree<T> {
    * Initializes an empty Red-Black Tree.
    * @param {(a: T, b: T) => number} [compare] - A custom comparator function. Default: numerical comparison.
    */
-  constructor(
-    private compare: (a: T, b: T) => number = (a, b) =>
-      a < b ? -1 : a > b ? 1 : 0
-  ) {
+  constructor(private compare: (a: T, b: T) => number = (a, b) => (a < b ? -1 : a > b ? 1 : 0)) {
     this.nil = new Node<T>(null as T, null!);
     this.nil.color = Color.BLACK;
     this.nil.left = this.nil.right = this.nil;
diff --git a/data-structures/trie/trie.test.ts b/data-structures/trie/trie.test.ts
@@ -28,9 +28,7 @@ describe('Trie', () => {
     trie.insert('app');
     trie.insert('application');
     trie.insert('banana');
-    expect(trie.findWords('app').sort()).toEqual(
-      ['app', 'apple', 'application'].sort()
-    );
+    expect(trie.findWords('app').sort()).toEqual(['app', 'apple', 'application'].sort());
     expect(trie.findWords('ban')).toEqual(['banana']);
     expect(trie.findWords('cat')).toEqual([]);
   });
diff --git a/data-structures/union-find/unionFind.ts b/data-structures/union-find/unionFind.ts
@@ -61,9 +61,7 @@ export class UnionFind<T> {
    */
   union(element1: T, element2: T): void {
     if (!this.parent.has(element1) || !this.parent.has(element2)) {
-      throw new Error(
-        `One or both elements (${element1}, ${element2}) not found in any set`
-      );
+      throw new Error(`One or both elements (${element1}, ${element2}) not found in any set`);
     }
 
     const root1 = this.find(element1);
diff --git a/eslint.config.js b/eslint.config.js
diff --git a/math/matrix/matrix.ts b/math/matrix/matrix.ts
diff --git a/math/sieveOfEratosthenes/sieveOfEratosthenes.test.ts b/math/sieveOfEratosthenes/sieveOfEratosthenes.test.ts
diff --git a/tsconfig.json b/tsconfig.json

Original file line number	Diff line number	Diff line change
`@@ -11,11 +11,11 @@ export function jumpSearch(arr: number[], x: number): number \| undefined {`
`11`	`11`	`}`
`12`	`12`	`while (arr[prev] < x) {`
`13`	`13`	`prev++;`
`14`		`- if (prev == Math.min(step, n)) {`
	`14`	`+ if (prev === Math.min(step, n)) {`
`15`	`15`	`return undefined;`
`16`	`16`	`}`
`17`	`17`	`}`
`18`		`- if (arr[prev] == x) {`
	`18`	`+ if (arr[prev] === x) {`
`19`	`19`	`return prev;`
`20`	`20`	`}`
`21`	`21`	`return undefined;`