Refactoring

Author: GolubevDS

README.MD

@@ -3,12 +3,13 @@
  *
  * @constructor
  * @param {number} val - The numeric value of the node.
+ * @param {ListNode} [next=null] - The next node in the list. Defaults to null.
  * @property {number} val - The numeric value of the node.
  * @property {ListNode | null} next - The next node in the linked list, or null if this is the last node.
  */
-function ListNode(val) {
+function ListNode(val, next = null) {
 	this.val = val;
-	this.next = null;
+	this.next = next;
 }
 
 module.exports = ListNode;

helpers/listNode.js

@@ -4,16 +4,12 @@
  */
 function modify(str) {
 	let backspaces = 0,
-	    result = '';
+	    result     = '';
 
 	for (let i = str.length - 1; i >= 0; i--) {
-		if (str[i] === '#') {
-			backspaces++;
-		} else if (backspaces > 0) {
-			backspaces--;
-		} else {
-			result = str[i] + result;
-		}
+		if (str[i] === '#') backspaces++;
+		else if (backspaces > 0) backspaces--;
+		else result = str[i] + result;
 	}
 
 	return result;

solutions/backspaceCompare/index.js …ons/backspaceCompare/backspaceCompare.jssolutions/backspaceCompare/index.js renamed to solutions/backspaceCompare/backspaceCompare.js solutions/backspaceCompare/index.js renamed to solutions/backspaceCompare/backspaceCompare.js

@@ -0,0 +1,39 @@
+const backspaceCompare = require('./backspaceCompare');
+
+describe('Backspace String Compare', () => {
+	it('returns true for identical strings', () => {
+		const s = 'abc#d';
+		const t = 'abc#d';
+		expect(backspaceCompare(s, t)).toBe(true);
+	});
+
+	it('returns false for different strings', () => {
+		const s = 'abc#d';
+		const t = 'abc##d';
+		expect(backspaceCompare(s, t)).toBe(false);
+	});
+
+	it('handles empty string inputs', () => {
+		const s = '';
+		const t = '';
+		expect(backspaceCompare(s, t)).toBe(true);
+	});
+
+	it('handles inputs with only backspaces', () => {
+		const s = '##';
+		const t = '###';
+		expect(backspaceCompare(s, t)).toBe(true);
+	});
+
+	it('handles inputs with only characters', () => {
+		const s = 'abcd';
+		const t = 'abcd';
+		expect(backspaceCompare(s, t)).toBe(true);
+	});
+
+	it('handles inputs with mixed characters and backspaces', () => {
+		const s = 'a##c';
+		const t = '#a#c';
+		expect(backspaceCompare(s, t)).toBe(true);
+	});
+});

solutions/backspaceCompare/backspaceCompare.spec.js

@@ -0,0 +1,16 @@
+const climbStairs = require('./climbStairs');
+
+describe('Climbing Stairs', () => {
+	it('climbStairs returns the correct result', () => {
+		expect(climbStairs(1)).toEqual(1);
+		expect(climbStairs(2)).toEqual(2);
+		expect(climbStairs(3)).toEqual(3);
+		expect(climbStairs(4)).toEqual(5);
+		expect(climbStairs(5)).toEqual(8);
+		expect(climbStairs(6)).toEqual(13);
+	});
+
+	it('returns the correct result for large values of n', () => {
+		expect(climbStairs(45)).toBe(1836311903);
+	});
+});

solutions/backspaceCompare/index.spec.js

@@ -6,9 +6,7 @@ function containsDuplicate(nums) {
 	const set = new Set();
 
 	for (let i = 0; i < nums.length; i++) {
-		if (set.has(nums[i])) {
-			return true;
-		}
+		if (set.has(nums[i])) return true;
 		set.add(nums[i]);
 	}
 

solutions/climbStairs/index.js solutions/climbStairs/climbStairs.jssolutions/climbStairs/index.js renamed to solutions/climbStairs/climbStairs.js

@@ -0,0 +1,15 @@
+const containsDuplicate = require('./containsDuplicate');
+
+describe('Contains Duplicate', () => {
+	test('should return true if array contains duplicate numbers', () => {
+		expect(containsDuplicate([1, 2, 3, 1])).toBe(true);
+		expect(containsDuplicate([1, 2, 3, 4, 5, 6, 7, 8, 9, 9])).toBe(true);
+		expect(containsDuplicate([1, 1])).toBe(true);
+	});
+
+	test('should return false if array does not contain duplicate numbers', () => {
+		expect(containsDuplicate([1, 2, 3, 4])).toBe(false);
+		expect(containsDuplicate([1])).toBe(false);
+		expect(containsDuplicate([])).toBe(false);
+	});
+});