Feat | Interview | #14 Find By Type

README.md

@@ -132,4 +132,5 @@ Interview Questions
 - [Task #10](src/interview/render-items/with-async) - _Render Items: With Async_
 - [Task #11](src/interview/build-tree/no-replies-sort) - _Build Tree: No Replies Sort_
 - [Task #12](src/interview/build-tree/with-replies-sort) - _Build Tree: With Replies Sort_
-- [Task #13](src/interview/build-comments-tree) - _Build Comments Tree_
+- [Task #13](src/interview/build-comments-tree) - _Build Comments Tree_
+- [Task #13](src/interview/find-by-type) - _Find By Type_

src/interview/find-by-type/solution.test.ts

@@ -0,0 +1,113 @@
+import { findByType } from './solution';
+
+describe('Find By Type | Interview | Testcases', () => {
+  test('#1 Follow upside-down order', () => {
+    const tree = {
+      type: 'folder',
+      name: 'root',
+      children: [
+        { type: 'file', name: 'file-1', children: [] },
+        {
+          type: 'folder',
+          name: 'docs',
+          children: [{ type: 'file', name: 'file-2', children: [] }],
+        },
+        { type: 'file', name: 'file-3', children: [] },
+      ],
+    };
+    expect(findByType(tree, 'file').map((node) => node.name)).toEqual([
+      'file-1',
+      'file-2',
+      'file-3',
+    ]);
+  });
+
+  test('#2 No nodes of requested type', () => {
+    const tree = {
+      type: 'folder',
+      name: 'root',
+      children: [
+        { type: 'folder', name: 'sub1', children: [] },
+        { type: 'folder', name: 'sub2', children: [] },
+      ],
+    };
+    expect(findByType(tree, 'file')).toEqual([]);
+  });
+
+  test('#3 All nodes are of requested type', () => {
+    const tree = {
+      type: 'file',
+      name: 'root-file',
+      children: [
+        { type: 'file', name: 'file-a', children: [] },
+        { type: 'file', name: 'file-b', children: [] },
+      ],
+    };
+    expect(findByType(tree, 'file').map((node) => node.name)).toEqual([
+      'root-file',
+      'file-a',
+      'file-b',
+    ]);
+  });
+
+  test('#4 Deep nesting', () => {
+    const tree = {
+      type: 'folder',
+      name: 'root',
+      children: [
+        {
+          type: 'folder',
+          name: 'level1',
+          children: [
+            {
+              type: 'folder',
+              name: 'level2',
+              children: [{ type: 'file', name: 'deep-file', children: [] }],
+            },
+          ],
+        },
+      ],
+    };
+    expect(findByType(tree, 'file').map((node) => node.name)).toEqual([
+      'deep-file',
+    ]);
+  });
+
+  test('#5 Multiple matches in different branches', () => {
+    const tree = {
+      type: 'folder',
+      name: 'root',
+      children: [
+        {
+          type: 'folder',
+          name: 'branch1',
+          children: [
+            { type: 'file', name: 'b1-f1', children: [] },
+            { type: 'file', name: 'b1-f2', children: [] },
+          ],
+        },
+        {
+          type: 'folder',
+          name: 'branch2',
+          children: [{ type: 'file', name: 'b2-f1', children: [] }],
+        },
+      ],
+    };
+    expect(findByType(tree, 'file').map((node) => node.name)).toEqual([
+      'b1-f1',
+      'b1-f2',
+      'b2-f1',
+    ]);
+  });
+
+  test('#6 Search for type that appears only in root', () => {
+    const tree = {
+      type: 'special',
+      name: 'root-special',
+      children: [{ type: 'file', name: 'file-1', children: [] }],
+    };
+    expect(findByType(tree, 'special').map((node) => node.name)).toEqual([
+      'root-special',
+    ]);
+  });
+});

src/interview/find-by-type/solution.ts

@@ -0,0 +1,48 @@
+interface Tree {
+  type: string;
+  name: string;
+  children: Tree[];
+}
+
+/**
+ * @param tree - nested object of nodes
+ * @param type - searching param to find nodes
+ *
+ * @example
+ *
+ * const tree = {
+ *   type: 'folder',
+ *   name: 'root',
+ *   children: [
+ *     { type: 'file', name: 'file-1', children: [] },
+ *     {
+ *       type: 'folder',
+ *       name: 'docs',
+ *       children: [{ type: 'file', name: 'file-2', children: [] }],
+ *     },
+ *     { type: 'file', name: 'file-3', children: [] },
+ *   ],
+ * };
+ *
+ * console.log(findByType(tree, 'file').map((node) => node.name));
+ * // Expected: ["file-1", "file-2", "file-3"]
+ */
+export const findByType = (tree: Tree, type: string): Tree[] => {
+  const matches: Tree[] = [];
+  const stack: Tree[] = [tree];
+
+  while (stack.length) {
+    const node = stack.pop();
+    if (node) {
+      if (node.type === type) {
+        matches.push(node);
+      }
+
+      for (let i = node.children.length - 1; i >= 0; i--) {
+        stack.push(node.children[i]);
+      }
+    }
+  }
+
+  return matches;
+};