feat: staircase steps algorithm

src/algorithms/steps/steps.ts

@@ -0,0 +1,31 @@
+// Option 1
+export const steps = (n: number) => {
+  for (let row = 0; row < n; row++) {
+    let stair = '';
+
+    for (let column = 0; column < n; column++) {
+      if (column <= row) {
+        stair += '#';
+      } else {
+        stair += ' ';
+      }
+    }
+
+    console.log(stair);
+  }
+};
+
+// Option 2
+export const stepsWithRecursion = (n: number, row = 0, stair = '') => {
+  if (n === row) {
+    return;
+  }
+
+  if (n === stair.length) {
+    console.log(stair);
+    return stepsWithRecursion(n, row + 1);
+  }
+
+  const add = stair.length <= row ? '#' : ' ';
+  stepsWithRecursion(n, row, stair + add);
+};

src/algorithms/steps/tests/steps.test.ts

@@ -0,0 +1,43 @@
+import { SpyInstance, describe, test, vi } from 'vitest';
+import { steps, stepsWithRecursion } from '../steps';
+
+describe('Steps Algorithm', () => {
+  let spy: SpyInstance;
+
+  beforeEach(() => {
+    spy = vi.spyOn(console, 'log').mockImplementation(() => {});
+  });
+
+  afterEach(() => {
+    spy.mockRestore();
+  });
+
+  test('steps is a function', () => {
+    expect(typeof steps).toEqual('function');
+    expect(typeof stepsWithRecursion).toEqual('function');
+  });
+
+  test('steps called with n = 1', () => {
+    steps(1);
+    stepsWithRecursion(1);
+    expect(spy.mock.calls[0][0]).toEqual('#');
+    expect(spy.mock.calls.length).toEqual(2);
+  });
+
+  test('steps called with n = 2', () => {
+    steps(2);
+    stepsWithRecursion(2);
+    expect(spy.mock.calls[0][0]).toEqual('# ');
+    expect(spy.mock.calls[1][0]).toEqual('##');
+    expect(spy.mock.calls.length).toEqual(4);
+  });
+
+  test('steps called with n = 3', () => {
+    steps(3);
+    stepsWithRecursion(3);
+    expect(spy.mock.calls[0][0]).toEqual('#  ');
+    expect(spy.mock.calls[1][0]).toEqual('## ');
+    expect(spy.mock.calls[2][0]).toEqual('###');
+    expect(spy.mock.calls.length).toEqual(6);
+  });
+});