style: 💄 format the codes with new linting rules

Author: dandedotdev

src/0001-1000/110/isBalanced.ts

@@ -1,5 +1,5 @@
-import { maxDepth } from '0001-1000/104/maxDepth'
 import { TreeNode } from 'classes/BinaryTreeNode'
+import { maxDepth } from '0001-1000/104/maxDepth'
 
 // A height-balanced binary tree is definedas a binary tree in which
 // the height of the left and the right subtree of any node differ by not more than 1.

src/0001-1000/23/mergeKLists2.ts

@@ -1,5 +1,5 @@
-import { MinPriorityQueue } from '@datastructures-js/priority-queue' // Leetcode
 import { ListNode } from 'classes/SinglyLinkedListNode'
+import { MinPriorityQueue } from '@datastructures-js/priority-queue' // Leetcode
 
 // <Priority Queue>
 // Time: O(knlogk), k is the number of lists

src/0001-1000/234/isPalindrome.ts

@@ -1,5 +1,5 @@
-import { reverseList } from '0001-1000/206/reverseList'
 import { ListNode } from 'classes/SinglyLinkedListNode'
+import { reverseList } from '0001-1000/206/reverseList'
 
 // <Fast-slow Pointers>
 // Time: O(n)

src/0001-1000/235/lowestCommonAncestor.ts

@@ -10,7 +10,7 @@ import { TreeNode } from 'classes/BinaryTreeNode'
 function lowestCommonAncestor(
     root: TreeNode | null,
     p: TreeNode | null,
-    q: TreeNode | null
+    q: TreeNode | null,
 ): TreeNode | null {
     // edge cases
     if (root === null || root === p || root === q) {

src/0001-1000/235/lowestCommonAncestor2.ts

@@ -25,7 +25,7 @@ function getPath(node: TreeNode, target: TreeNode): TreeNode[] {
 function lowestCommonAncestor(
     root: TreeNode | null,
     p: TreeNode | null,
-    q: TreeNode | null
+    q: TreeNode | null,
 ): TreeNode | null {
     // edge cases
     if (!root) {

src/0001-1000/236/lowestCommonAncestor.ts

@@ -7,7 +7,7 @@ import { TreeNode } from 'classes/BinaryTreeNode'
 function lowestCommonAncestor(
     root: TreeNode | null,
     p: TreeNode | null,
-    q: TreeNode | null
+    q: TreeNode | null,
 ): TreeNode | null {
     let ans: TreeNode | null = null
 

src/0001-1000/236/lowestCommonAncestor2.ts

@@ -7,7 +7,7 @@ import { TreeNode } from 'classes/BinaryTreeNode'
 function lowestCommonAncestor(
     root: TreeNode | null,
     p: TreeNode | null,
-    q: TreeNode | null
+    q: TreeNode | null,
 ): TreeNode | null {
     // constraints: all Node.val are unique
     const parent = new Map<number, TreeNode>()

src/0001-1000/236/lowestCommonAncestor3.ts

@@ -7,7 +7,7 @@ import { TreeNode } from 'classes/BinaryTreeNode'
 function lowestCommonAncestor(
     root: TreeNode | null,
     p: TreeNode | null,
-    q: TreeNode | null
+    q: TreeNode | null,
 ): TreeNode | null {
     // edge cases
     if (root === null || root === p || root === q) {

src/0001-1000/315/countSmaller.ts

@@ -10,7 +10,7 @@ function merge(
     counts: number[],
     left: number,
     mid: number,
-    right: number
+    right: number,
 ): void {
     let [i, j] = [left, mid + 1]
     let p = 0
@@ -54,7 +54,7 @@ function sort(
     temp: number[],
     counts: number[],
     left: number,
-    right: number
+    right: number,
 ): void {
     if (left >= right) {
         return

src/0001-1000/315/countSmaller2.ts

@@ -10,7 +10,7 @@ function merge(
     counts: number[],
     left: number,
     mid: number,
-    right: number
+    right: number,
 ): void {
     for (let i = left; i <= right; ++i) {
         temp[i] = indexes[i]
@@ -45,7 +45,7 @@ function sort(
     temp: number[],
     counts: number[],
     left: number,
-    right: number
+    right: number,
 ): void {
     if (left >= right) {
         return

src/0001-1000/337/rob.ts

@@ -15,7 +15,7 @@ import { TreeNode } from 'classes/BinaryTreeNode'
 function dfs(
     node: TreeNode | null,
     robbed: Map<TreeNode | null, number>,
-    safe: Map<TreeNode | null, number>
+    safe: Map<TreeNode | null, number>,
 ): void {
     if (!node) {
         return
@@ -28,7 +28,7 @@ function dfs(
     safe.set(
         node,
         Math.max(robbed.get(node.left) ?? 0, safe.get(node.left) ?? 0) +
-            Math.max(robbed.get(node.right) ?? 0, safe.get(node.right) ?? 0)
+            Math.max(robbed.get(node.right) ?? 0, safe.get(node.right) ?? 0),
     )
 }
 

src/0001-1000/437/pathSum2.ts

@@ -9,7 +9,7 @@ function dfs(
     node: TreeNode | null,
     sum: number,
     targetSum: number,
-    prefixSum: Map<number, number>
+    prefixSum: Map<number, number>,
 ): number {
     // edge cases
     if (!node) {

src/0001-1000/445/addTwoNumbers.ts

@@ -1,6 +1,6 @@
+import { ListNode } from 'classes/SinglyLinkedListNode'
 import { addTwoNumbers as addTwoNumbersHelper } from '0001-1000/2/addTwoNumbers'
 import { reverseList } from '0001-1000/206/reverseList'
-import { ListNode } from 'classes/SinglyLinkedListNode'
 
 // <Recursion, Math>
 // Time: O(max(n, m))

src/0001-1000/449/serializeAndDeserialize.ts

@@ -1,5 +1,5 @@
-import { serialize } from '0001-1000/297/serializeAndDeserialize'
 import { TreeNode } from 'classes/BinaryTreeNode'
+import { serialize } from '0001-1000/297/serializeAndDeserialize'
 
 // Notice that the root is the root of the BST
 
@@ -17,7 +17,7 @@ import { TreeNode } from 'classes/BinaryTreeNode'
 function dfsDeserialize(
     dataList: string[],
     lower: number = -Infinity,
-    upper: number = Infinity
+    upper: number = Infinity,
 ): TreeNode | null {
     // edge cases
     if (dataList[0] === '#') {

src/0001-1000/508/findFrequentTreeSum.ts

@@ -8,7 +8,7 @@ import { TreeNode } from 'classes/BinaryTreeNode'
 function dfs(
     node: TreeNode | null,
     countMap: Map<number, number>,
-    maxCount: { value: number }
+    maxCount: { value: number },
 ): number {
     // edge cases
     if (!node) {

src/0001-1000/572/isSubtree.ts

@@ -1,5 +1,5 @@
-import { isSameTree } from '0001-1000/100/isSameTree'
 import { TreeNode } from 'classes/BinaryTreeNode'
+import { isSameTree } from '0001-1000/100/isSameTree'
 
 // <Recursion, DFS>
 // Time: O(nm)

src/0001-1000/70/climbStairs2.ts

@@ -7,7 +7,7 @@
 function multiply(a: number[][], b: number[][]): number[][] {
     const res = [
         [0, 0],
-        [0, 0]
+        [0, 0],
     ]
 
     for (let i = 0; i < 2; ++i) {
@@ -22,7 +22,7 @@ function multiply(a: number[][], b: number[][]): number[][] {
 function power(a: number[][], n: number): number[][] {
     let res = [
         [1, 0],
-        [0, 1]
+        [0, 1],
     ]
 
     while (n > 0) {
@@ -42,7 +42,7 @@ function power(a: number[][], n: number): number[][] {
 function climbStairs(n: number): number {
     const m = [
         [1, 1],
-        [1, 0]
+        [1, 0],
     ]
 
     const ans = power(m, n)

src/classes/BinaryIndexedTree.ts

@@ -10,7 +10,7 @@ class BinaryIndexedTree<T> {
     constructor(
         public size: number,
         readonly defaultValue: T,
-        readonly operation: (existing: T, applied: T) => T
+        readonly operation: (existing: T, applied: T) => T,
     ) {
         this.tree = new Array(size + 1).fill(defaultValue)
     }

src/utils/discretizer/discretizerFactory.ts

@@ -2,7 +2,7 @@ function discretizerFactory<T>(arr: T[], comparator: (a: T, b: T) => number): Ma
     return new Map(
         Array.from(new Set(arr))
             .sort(comparator)
-            .map((n, i) => [n, i])
+            .map((n, i) => [n, i]),
     )
 }