[REFACTOR] [Hacker Rank] Interview Preparation Kit: Search: Swap Nodes [Algo]. ESLint manual fixes: no-param-reassign fixed by OOP new solution.

Gonzalo Diaz · Gonzalo Diaz · commit 350180f98a2e · 2024-08-22T17:42:36.000-04:00
https://eslint.org/docs/latest/rules/no-param-reassign
diff --git a/src/hackerrank/interview_preparation_kit/search/swap_nodes_algo.big.test.ts b/src/hackerrank/interview_preparation_kit/search/swap_nodes_algo.big.test.ts
@@ -1,26 +1,25 @@
 import { describe, expect, it } from '@jest/globals';
 
-import { Node } from '../../lib/Node';
-import { swapNodes, buildTree, flatTree } from './swap_nodes_algo';
+import { Tree, swapNodes } from './swap_nodes_algo';
 import BIG_TEST_CASES from './swap_nodes_algo.big.testcases.json';
 
 describe('swap_nodes_algo', () => {
   it('buildTree and plain test cases', () => {
     expect.assertions(1);
 
     BIG_TEST_CASES.forEach((test) => {
-      const tToTest: Node<number> = buildTree(test.nodes);
-      const tResult: number[] = flatTree(tToTest);
+      const tree: Tree = new Tree(test.nodes);
+      const tresult: number[] = tree.flatTree();
 
-      expect(tResult).toStrictEqual(test.flattened);
+      expect(tresult).toStrictEqual(test.flattened);
     });
   });
 
   it('swapNodes test cases', () => {
     expect.assertions(1);
 
     BIG_TEST_CASES.forEach((test) => {
-      const tResult: number[][] = swapNodes(test.nodes, test.queries);
+      const tResult = swapNodes(test.nodes, test.queries);
 
       expect(tResult).toStrictEqual(test.expected);
     });
diff --git a/src/hackerrank/interview_preparation_kit/search/swap_nodes_algo.test.ts b/src/hackerrank/interview_preparation_kit/search/swap_nodes_algo.test.ts
@@ -1,37 +1,43 @@
 import { describe, expect, it } from '@jest/globals';
 
-import { buildTree, flatTree, swapNodes } from './swap_nodes_algo';
+import { Node } from '../../lib/Node';
+import { Tree, swapNodes, __INITIAL_LEVEL__ } from './swap_nodes_algo';
 import TEST_CASES from './swap_nodes_algo.testcases.json';
 
 describe('swap_nodes_algo', () => {
   it('test_buildTree_empty', () => {
-    expect.assertions(1);
+    expect.assertions(4);
 
-    const tInput: number[][] = [];
-    const tToTest = buildTree(tInput);
-    const tResult = flatTree(tToTest);
-    const expected = [1];
+    const input: number[][] = [];
+    const tree: Tree = new Tree(input);
+    const expected: number[] = [1];
 
-    expect(tResult).toStrictEqual(expected);
+    expect(tree.flatTree()).toStrictEqual(expected);
+    expect(tree.getRoot()).not.toBeNull();
+    expect(tree.getRoot()).toBeInstanceOf(Node);
+    expect(tree.getRoot().data).toBe(__INITIAL_LEVEL__);
   });
 
   it('test_build_malformed_tree', () => {
-    expect.assertions(1);
+    expect.assertions(4);
 
-    const tInput: number[][] = [[], []];
-    const tToTest = buildTree(tInput);
-    const tResult = flatTree(tToTest);
-    const expected = [1];
+    const input: number[][] = [[], []];
+    const tree: Tree = new Tree(input);
+    const tresult: number[] = tree.flatTree();
+    const expected: number[] = [__INITIAL_LEVEL__];
 
-    expect(tResult).toStrictEqual(expected);
+    expect(tresult).toStrictEqual(expected);
+    expect(tree.getRoot()).not.toBeNull();
+    expect(tree.getRoot()).toBeInstanceOf(Node);
+    expect(tree.getRoot().data).toBe(__INITIAL_LEVEL__);
   });
 
   it('build tree and flattened tree test cases', () => {
     expect.assertions(4);
 
     TEST_CASES.forEach((test) => {
-      const tToTest = buildTree(test.nodes);
-      const tResult = flatTree(tToTest);
+      const tree = new Tree(test.nodes);
+      const tResult = tree.flatTree();
 
       expect(tResult).toStrictEqual(test.flattened);
     });
diff --git a/src/hackerrank/interview_preparation_kit/search/swap_nodes_algo.ts b/src/hackerrank/interview_preparation_kit/search/swap_nodes_algo.ts
@@ -2,7 +2,6 @@
  * @link Problem export functioninition [[docs/hackerrank/interview_preparation_kit/search/swap-nodes-algo.md]]
  */
 
-import { logger as console } from '../../../logger';
 import { Node } from '../../lib/Node';
 
 // CONSTANTS
@@ -11,147 +10,104 @@ export const __ROOT_VALUE__: number = 1;
 export const __LEAF_VALUE__: number = -1;
 const __RADIX__ = 10;
 
-export function callbackCollectNodes(
-  root: Node<number> | null | undefined,
-  collect: Record<number, Node<number>[]>,
-  level: number
-): void {
-  if (root) {
-    if (collect?.[level] === undefined) {
-      collect[level] = [root];
-    } else {
-      collect[level].push(root);
-    }
-  }
-}
+export class Tree {
+  root: Node<number>;
 
-export function callbackCollectFlat(
-  root: Node<number> | null | undefined,
-  collect: Record<number, Node<number>[]>,
-  level: number
-): void {
-  const _level: number = 0 * level; // set a unique key to use dict as a list
-  if (root) {
-    if (collect?.[_level] === undefined) {
-      collect[_level] = [root];
-    } else {
-      collect[_level].push(root);
-    }
-  }
-}
+  nodeCollector: Record<number, Node<number>[]>;
+
+  constructor(indexes: number[][]) {
+    this.root = new Node(__ROOT_VALUE__);
+    this.nodeCollector = {};
+    this.nodeCollector[__INITIAL_LEVEL__] = [this.root];
 
-export function traverseInOrderCollector(
-  root: Node<number> | null | undefined,
-  collect: Record<number, Node<number>[]>,
-  level: number,
-  callbackFn: (
-    root: Node<number> | null | undefined,
-    collect: Record<number, Node<number>[]>,
-    level: number
-  ) => void
-): Record<number, Node<number>[]> {
-  if (root?.left !== null) {
-    traverseInOrderCollector(root?.left, collect, level + 1, callbackFn);
+    this.buildTree(indexes);
   }
 
-  callbackFn(root, collect, level);
+  buildTree(indexes: number[][]): Tree {
+    const indexesCopy = [...indexes];
+    let currentLevel = __INITIAL_LEVEL__;
 
-  if (root?.right !== null) {
-    traverseInOrderCollector(root?.right, collect, level + 1, callbackFn);
-  }
+    while (indexesCopy.length > 0) {
+      const levelSize = Math.min(
+        indexesCopy.length,
+        this.nodeCollector[currentLevel]?.length
+      );
 
-  return collect;
-}
+      const nextLevel = currentLevel + 1;
 
-export function buildTree(indexes: number[][]): Node<number> {
-  const indexesCopy: number[][] = [...indexes];
-  const root: Node<number> = new Node<number>(__ROOT_VALUE__);
-  let nodeCollector: Record<number, Node<number>[]> = {};
-
-  while (indexesCopy.length > 0) {
-    nodeCollector = {};
-
-    traverseInOrderCollector(
-      root,
-      nodeCollector,
-      __INITIAL_LEVEL__,
-      callbackCollectNodes
-    );
-
-    const lastLevel: number = parseInt(
-      Object.keys(nodeCollector)
-        .sort((a, b) => parseInt(b, __RADIX__) - parseInt(a, __RADIX__))
-        .shift() as string,
-      __RADIX__
-    );
-
-    const levelSize = Math.min(
-      indexesCopy.length,
-      nodeCollector[lastLevel]?.length
-    );
-    for (let i = 0; i < levelSize; i++) {
-      const currentNode: Node<number> = nodeCollector[lastLevel][i];
-      const newElement: number[] = indexesCopy.shift() as Array<number>;
-
-      if ((newElement?.[0] ?? __LEAF_VALUE__) !== __LEAF_VALUE__) {
-        currentNode.left = new Node<number>(newElement[0]);
+      if (levelSize > 0) {
+        this.nodeCollector[nextLevel] = [];
       }
-      if ((newElement?.[1] ?? __LEAF_VALUE__) !== __LEAF_VALUE__) {
-        currentNode.right = new Node<number>(newElement[1]);
+
+      for (let i = 0; i < levelSize; i++) {
+        const currentNode = this.nodeCollector[currentLevel][i];
+        const newElement = indexesCopy?.shift() ?? [];
+
+        if ((newElement?.[0] ?? __LEAF_VALUE__) !== __LEAF_VALUE__) {
+          currentNode.left = new Node(newElement[0]);
+          this.nodeCollector[nextLevel].push(currentNode.left);
+        }
+        if ((newElement?.[1] ?? __LEAF_VALUE__) !== __LEAF_VALUE__) {
+          currentNode.right = new Node(newElement[1]);
+          this.nodeCollector[nextLevel].push(currentNode.right);
+        }
+      }
+
+      if (this.nodeCollector[nextLevel].length > 0) {
+        currentLevel = nextLevel;
       }
     }
+
+    return this;
   }
 
-  return root;
-}
+  getRoot(): Node<number> {
+    return this.root;
+  }
 
-export function flatTree(root: Node<number> | null): number[] {
-  let nodeCollector: Record<number, Node<number>[]> = {};
+  getCollector(): Record<number, Node<number>[]> {
+    return this.nodeCollector;
+  }
 
-  nodeCollector = traverseInOrderCollector(
-    root,
-    nodeCollector,
-    __INITIAL_LEVEL__,
-    callbackCollectFlat
-  );
+  flatTree(): number[] {
+    const flatTreeCollector: Node<number>[] = [];
 
-  const lastLevel: number = parseInt(
-    Object.keys(nodeCollector)
-      .sort((a, b) => parseInt(b, __RADIX__) - parseInt(a, __RADIX__))
-      .shift() as string,
-    __RADIX__
-  );
+    function traverseInOrderFlat(node: Node<number>): void {
+      if (node?.left !== null) {
+        traverseInOrderFlat(node?.left);
+      }
 
-  const output: number[] = [];
-  nodeCollector[lastLevel].forEach((node: Node<number>) => {
-    output.push(node.data);
-  });
+      if (node) {
+        flatTreeCollector.push(node);
+      }
 
-  return output;
+      if (node?.right !== null) {
+        traverseInOrderFlat(node?.right);
+      }
+    }
+
+    traverseInOrderFlat(this.root);
+
+    const output: number[] = [];
+    flatTreeCollector.forEach((node) => {
+      output.push(node.data);
+    });
+
+    return output;
+  }
 }
 
 export function swapNodes(indexes: number[][], queries: number[]): number[][] {
-  const tree: Node<number> = buildTree(indexes);
+  const tree: Tree = new Tree(indexes);
+  let nodeCollector: Record<number, Node<number>[]> = tree.getCollector();
   const output: number[][] = [];
-  let nodeCollector: Record<number, Node<number>[]> = {};
-
-  traverseInOrderCollector(
-    tree,
-    nodeCollector,
-    __INITIAL_LEVEL__,
-    callbackCollectNodes
-  );
 
   nodeCollector = Object.fromEntries(
     Object.entries(nodeCollector).sort(
       ([a], [b]) => parseInt(a, __RADIX__) - parseInt(b, __RADIX__)
     )
   );
 
-  let flattenedTree: number[] = flatTree(tree);
-
-  console.debug(`Plain tree: ${flattenedTree}`);
-
   for (const query of queries) {
     for (const [level, nodeList] of Object.entries(nodeCollector)) {
       const tLevel: number = parseInt(level, __RADIX__);
@@ -164,8 +120,7 @@ export function swapNodes(indexes: number[][], queries: number[]): number[][] {
       }
     }
 
-    flattenedTree = flatTree(tree);
-    output.push(flattenedTree);
+    output.push(tree.flatTree());
   }
 
   return output;
