[Hacker Rank] Interview Preparation Kit: Search: Swap Nodes [Algo]. First solution.

Author: Gonzalo Diaz

src/hackerrank/interview_preparation_kit/search/swap_nodes_algo.test.ts

@@ -1,6 +1,13 @@
 import { describe, expect, it } from '@jest/globals';
 
-import { build_tree, flat_tree } from './swap_nodes_algo';
+import { Node } from '../../lib/Node';
+import {
+  build_tree,
+  flat_tree,
+  swap_branch,
+  swapNodes,
+  __INITIAL_LEVEL__
+} from './swap_nodes_algo';
 import TEST_CASES from './swap_nodes_algo.testcases.json';
 
 describe('swap_nodes_algo', () => {
@@ -26,6 +33,28 @@ describe('swap_nodes_algo', () => {
     expect(t_result).toStrictEqual(expected);
   });
 
+  it('test_swap_branch empty', () => {
+    expect.assertions(1);
+
+    const t_input: null = null;
+    const t_result: Node<number> | null = swap_branch(t_input);
+    const expected = null;
+
+    expect(t_result).toStrictEqual(expected);
+  });
+
+  it('test_swap_branch', () => {
+    expect.assertions(1);
+
+    const t_input: Node<number> = new Node<number>(__INITIAL_LEVEL__);
+    t_input.left = new Node<number>(2);
+    t_input.right = new Node<number>(3);
+    const t_result: number[] = flat_tree(swap_branch(t_input));
+    const expected: number[] = [3, 1, 2];
+
+    expect(t_result).toStrictEqual(expected);
+  });
+
   it('build_tree and plain test cases', () => {
     expect.assertions(4);
 
@@ -36,4 +65,14 @@ describe('swap_nodes_algo', () => {
       expect(t_result).toStrictEqual(test.plain);
     });
   });
+
+  it('swapNodes test cases', () => {
+    expect.assertions(4);
+
+    TEST_CASES.forEach((test) => {
+      const t_result: number[][] = swapNodes(test.nodes, test.queries);
+
+      expect(t_result).toStrictEqual(test.expected);
+    });
+  });
 });

src/hackerrank/interview_preparation_kit/search/swap_nodes_algo.testcases.json

@@ -4,22 +4,22 @@
     "nodes": [[2, 3], [-1, -1], [-1, -1]],
     "plain": [2, 1, 3],
     "queries": [1, 1],
-    "answer": [[3, 1, 2], [2, 1, 3]]
+    "expected": [[3, 1, 2], [2, 1, 3]]
   },
   {
     "title": "Sample 1",
     "nodes": [[2, 3], [-1, 4], [-1, 5], [-1, -1], [-1, -1]],
     "plain": [2, 4, 1, 3, 5],
     "queries": [2],
-    "answer": [[4, 2, 1, 5, 3]]
+    "expected": [[4, 2, 1, 5, 3]]
   },
   {
     "title": "Sample 2",
     "nodes": [[2, 3], [4, -1], [5, -1], [6, -1], [7, 8], [-1, 9],
           [-1, -1], [10, 11], [-1, -1], [-1, -1], [-1, -1]],
     "plain": [6, 9, 4, 2, 1, 7, 5, 10, 8, 11, 3],
     "queries": [2, 4],
-    "answer": [[2, 9, 6, 4, 1, 3, 7, 5, 11, 8, 10],
+    "expected": [[2, 9, 6, 4, 1, 3, 7, 5, 11, 8, 10],
           [2, 6, 9, 4, 1, 3, 7, 5, 10, 8, 11]]
   },
   {
@@ -29,7 +29,7 @@
           [-1, -1], [-1, -1], [-1, -1], [-1, -1]],
     "plain": [4, 12, 7, 13, 2, 8, 14, 5, 9, 1, 15, 10, 6, 16, 11, 17, 3],
     "queries": [2, 3],
-    "answer": [[14, 8, 5, 9, 2, 4, 13, 7, 12, 1, 3, 10, 15, 6, 17, 11, 16],
+    "expected": [[14, 8, 5, 9, 2, 4, 13, 7, 12, 1, 3, 10, 15, 6, 17, 11, 16],
           [9, 5, 14, 8, 2, 13, 7, 12, 4, 1, 3, 17, 11, 16, 6, 10, 15]]
   }
 ]

src/hackerrank/interview_preparation_kit/search/swap_nodes_algo.ts

@@ -2,57 +2,61 @@
  * @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
-const __INITIAL_LEVEL__: number = 1;
-const __ROOT_VALUE__: number = 1;
-const __LEAF_VALUE__: number = -1;
+export const __INITIAL_LEVEL__: number = 1;
+export const __ROOT_VALUE__: number = 1;
+export const __LEAF_VALUE__: number = -1;
 
 export function callback_collect_nodes(
-  root: Node<number>,
+  root: Node<number> | null | undefined,
   collect: Record<number, Node<number>[]>,
   level: number
 ): void {
-  if (collect?.[level] === undefined) {
-    collect[level] = [root];
-  } else {
-    collect[level].push(root);
+  if (root) {
+    if (collect?.[level] === undefined) {
+      collect[level] = [root];
+    } else {
+      collect[level].push(root);
+    }
   }
 }
 
 export function callback_collect_flat(
-  root: Node<number>,
+  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 (collect?.[_level] === undefined) {
-    collect[_level] = [root];
-  } else {
-    collect[_level].push(root);
+  if (root) {
+    if (collect?.[_level] === undefined) {
+      collect[_level] = [root];
+    } else {
+      collect[_level].push(root);
+    }
   }
 }
 
 export function traverse_in_order_collector(
-  root: Node<number>,
+  root: Node<number> | null | undefined,
   collect: Record<number, Node<number>[]>,
   level: number,
   callbackFn: (
-    root: Node<number>,
+    root: Node<number> | null | undefined,
     collect: Record<number, Node<number>[]>,
     level: number
   ) => void
 ): Record<number, Node<number>[]> {
-  if (root.left !== null) {
-    traverse_in_order_collector(root.left, collect, level + 1, callbackFn);
+  if (root?.left !== null) {
+    traverse_in_order_collector(root?.left, collect, level + 1, callbackFn);
   }
 
   callbackFn(root, collect, level);
 
-  if (root.right !== null) {
-    traverse_in_order_collector(root.right, collect, level + 1, callbackFn);
+  if (root?.right !== null) {
+    traverse_in_order_collector(root?.right, collect, level + 1, callbackFn);
   }
 
   return collect;
@@ -97,7 +101,7 @@ export function build_tree(indexes: number[][]): Node<number> {
   return root;
 }
 
-export function flat_tree(root: Node<number>): number[] {
+export function flat_tree(root: Node<number> | null): number[] {
   let node_collector: Record<number, Node<number>[]> = {};
 
   node_collector = traverse_in_order_collector(
@@ -121,8 +125,51 @@ export function flat_tree(root: Node<number>): number[] {
   return output;
 }
 
+export function swap_branch(root: Node<number> | null): Node<number> | null {
+  if (root) {
+    [root.left, root.right] = [root.right, root.left];
+  }
+
+  return root;
+}
+
 export function swapNodes(indexes: number[][], queries: number[]): number[][] {
-  return [];
+  const tree: Node<number> = build_tree(indexes);
+
+  const output: number[][] = [];
+  let node_collector: Record<number, Node<number>[]> = {};
+
+  traverse_in_order_collector(
+    tree,
+    node_collector,
+    __INITIAL_LEVEL__,
+    callback_collect_nodes
+  );
+
+  node_collector = Object.fromEntries(
+    Object.entries(node_collector).sort(([a], [b]) => parseInt(a) - parseInt(b))
+  );
+
+  let flattened_tree: number[] = flat_tree(tree);
+
+  console.debug(`Plain tree: ${flattened_tree}`);
+
+  for (const query in queries) {
+    for (const [level, node_list] of Object.entries(node_collector)) {
+      const t_level: number = parseInt(level);
+
+      if (t_level % queries[query] == 0) {
+        for (const node of node_list) {
+          swap_branch(node);
+        }
+      }
+    }
+
+    flattened_tree = flat_tree(tree);
+    output.push(flattened_tree);
+  }
+
+  return output;
 }
 
-export default { swapNodes };
+export default { swapNodes, __INITIAL_LEVEL__ };