[REFACTOR] [Hacker Rank] Interview Preparation Kit: Recursion: Davis' Staircase. Problem rewritten as OOP to avoid "no-param-reassign". Clean code: better test cases data naming.

Author: Gonzalo Diaz

src/hackerrank/interview_preparation_kit/recursion_and_backtracking/ctci_recursive_staircase.js

@@ -4,31 +4,45 @@
  */
 
 const TOP_LIMIT = 10 ** 10 + 7;
-const STEPS_LIMIT = 3;
-const CACHE = {};
+const STEPSLIMIT = 3;
 
-export function stepPermsComputWithCache(nSteps, stepsLimit) {
-  if (nSteps >= 0 && nSteps <= 2) {
-    return nSteps;
+export class StepPerms {
+  TOP_LIMIT = 1;
+
+  STEPS_LIMIT = 1;
+
+  CACHE = {};
+
+  constructor(topLimit, stepsLimit) {
+    this.TOP_LIMIT = topLimit;
+    this.STEPS_LIMIT = stepsLimit;
   }
 
-  const keys = new Set(Object.keys(CACHE));
-  let result = 0;
+  stepPermsComputWithCache(nSteps) {
+    if (nSteps >= 0 && nSteps <= 2) {
+      return nSteps;
+    }
+
+    const keys = new Set(Object.keys(this.CACHE));
+    let result = 0;
+
+    for (let i = 1; i <= Math.min(this.STEPS_LIMIT, nSteps); i++) {
+      const searchKey = nSteps - i;
+      if (!keys.has(searchKey.toString())) {
+        this.CACHE[searchKey] = this.stepPermsComputWithCache(searchKey);
+      }
 
-  for (let i = 1; i <= Math.min(stepsLimit, nSteps); i++) {
-    const searchKey = nSteps - i;
-    if (!keys.has(searchKey)) {
-      CACHE[searchKey] = stepPermsComputWithCache(searchKey, stepsLimit);
+      result += this.CACHE[searchKey];
     }
 
-    result += CACHE[searchKey];
+    return result + (nSteps <= this.STEPS_LIMIT ? 1 : 0);
   }
-
-  return result + (nSteps <= stepsLimit ? 1 : 0);
 }
 
 export function stepPerms(n) {
-  return stepPermsComputWithCache(n, STEPS_LIMIT) % TOP_LIMIT;
+  const stairs = new StepPerms(TOP_LIMIT, STEPSLIMIT);
+
+  return stairs.stepPermsComputWithCache(n) % TOP_LIMIT;
 }
 
-export default { stepPerms, stepPermsComputWithCache };
+export default { stepPerms, StepPerms };

src/hackerrank/interview_preparation_kit/recursion_and_backtracking/ctci_recursive_staircase.test.js

@@ -1,10 +1,7 @@
 import { describe, expect, it } from '@jest/globals';
 import { logger as console } from '../../../logger.js';
 
-import {
-  stepPerms,
-  stepPermsComputWithCache
-} from './ctci_recursive_staircase.js';
+import { stepPerms, StepPerms } from './ctci_recursive_staircase.js';
 import TEST_CASES from './ctci_recursive_staircase.testcases.json';
 import TEST_CASES_GENERALIZED from './ctci_recursive_staircase_generalized.testcases.json';
 
@@ -14,9 +11,9 @@ describe('ctci_recursive_staircase', () => {
 
     TEST_CASES.forEach((testSet) => {
       testSet?.tests.forEach((test) => {
-        const answer = stepPerms(test.input);
+        const answer = stepPerms(test.n_steps);
 
-        console.debug(`stepPerms(${test.input}) solution found: ${answer}`);
+        console.debug(`stepPerms(${test.n_steps}) solution found: ${answer}`);
 
         expect(answer).toStrictEqual(test.expected);
       });
@@ -26,9 +23,13 @@ describe('ctci_recursive_staircase', () => {
   it('stepPermsComputWithCache test cases', () => {
     expect.assertions(3);
 
+    const TOP_LIMIT = 10 ** 10 + 7;
+
     TEST_CASES_GENERALIZED.forEach((testSet) => {
       testSet?.tests.forEach((test) => {
-        const answer = stepPermsComputWithCache(test.input, test.limit);
+        const stairs = new StepPerms(TOP_LIMIT, test.steps_limit);
+
+        const answer = stairs.stepPermsComputWithCache(test.n_steps);
 
         console.debug(
           `stepPermsComputWithCache(${test.input}, ${test.limit}) solution found: ${answer}`

src/hackerrank/interview_preparation_kit/recursion_and_backtracking/ctci_recursive_staircase.testcases.json

@@ -1,49 +1,49 @@
 [
-    {
-        "title": "Sample Test case 0",
-        "tests": [
-            {
-                "input": 1,
-                "expected": 1
-            },
-            {
-                "input": 3,
-                "expected": 4
-            },
-            {
-                "input": 7,
-                "expected": 44
-            }
-        ]
-    },
-    {
-        "title": "Sample Test case 9",
-        "tests": [
-            {
-                "input": 5,
-                "expected": 13
-            },
-            {
-                "input": 8,
-                "expected": 81
-            }
-        ]
-    },
-    {
-        "title": "Sample Test case 10",
-        "tests": [
-            {
-                "input": 15,
-                "expected": 5768
-            },
-            {
-                "input": 20,
-                "expected": 121415
-            },
-            {
-                "input": 27,
-                "expected": 8646064
-            }
-        ]
-    }
+  {
+    "title": "Sample Test case 0",
+    "tests": [
+      {
+        "n_steps": 1,
+        "expected": 1
+      },
+      {
+        "n_steps": 3,
+        "expected": 4
+      },
+      {
+        "n_steps": 7,
+        "expected": 44
+      }
+    ]
+  },
+  {
+    "title": "Sample Test case 9",
+    "tests": [
+      {
+        "n_steps": 5,
+        "expected": 13
+      },
+      {
+        "n_steps": 8,
+        "expected": 81
+      }
+    ]
+  },
+  {
+    "title": "Sample Test case 10",
+    "tests": [
+      {
+        "n_steps": 15,
+        "expected": 5768
+      },
+      {
+        "n_steps": 20,
+        "expected": 121415
+      },
+      {
+        "n_steps": 27,
+        "expected": 8646064
+      }
+    ]
+  }
 ]

src/hackerrank/interview_preparation_kit/recursion_and_backtracking/ctci_recursive_staircase_generalized.testcases.json

@@ -3,8 +3,8 @@
     "title": "Own sample 1",
     "tests": [
       {
-        "input": 4,
-        "limit": 3,
+        "n_steps": 4,
+        "steps_limit": 3,
         "expected": 7
       }
     ]
@@ -13,8 +13,8 @@
     "title": "Own sample 2",
     "tests": [
       {
-        "input": 5,
-        "limit": 4,
+        "n_steps": 5,
+        "steps_limit": 4,
         "expected": 15
       }
     ]
@@ -23,8 +23,8 @@
     "title": "Own sample 3",
     "tests": [
       {
-        "input": 6,
-        "limit": 2,
+        "n_steps": 6,
+        "steps_limit": 2,
         "expected": 13
       }
     ]