Min Cost Climbing Stairs & Number of Steps to Reduce a Number to Zero & Fizz Buzz & Ransom Note

Author: GolubevDS

README.MD

@@ -5,8 +5,5 @@
   },
   "scripts": {
     "test": "jest"
-  },
-  "jest": {
-    "verbose": true
   }
 }

package.json

@@ -0,0 +1,5 @@
+## [383. Ransom Note](https://leetcode.com/problems/ransom-note/)
+
+Given two strings `ransomNote` and `magazine`, return `true` if `ransomNote` can be constructed by using the letters from `magazine` and `false` otherwise.
+
+Each letter in `magazine` can only be used once in `ransomNote`.

solutions/canConstruct/README.MD

@@ -0,0 +1,25 @@
+/**
+ * @param {string} ransomNote
+ * @param {string} magazine
+ * @return {boolean}
+ */
+function canConstruct(ransomNote, magazine) {
+	if (ransomNote.length > magazine.length) return false;
+
+	const result = {};
+
+	for (const letter of magazine) {
+		result[letter] = result[letter]
+			? result[letter] + 1
+			: 1;
+	}
+
+	for (const letter of ransomNote) {
+		if (!result[letter]) return false;
+		result[letter]--;
+	}
+
+	return true;
+}
+
+module.exports = canConstruct;

solutions/canConstruct/canConstruct.js

@@ -0,0 +1,28 @@
+const canConstruct = require('./canConstruct');
+
+describe('Ransom Note', () => {
+	it('returns true if ransomNote can be constructed from magazine', () => {
+		expect(canConstruct('a', 'a')).toBe(true);
+		expect(canConstruct('aa', 'aab')).toBe(true);
+		expect(canConstruct('aab', 'baa')).toBe(true);
+		expect(canConstruct('ab', 'baa')).toBe(true);
+		expect(canConstruct('abc', 'abdefc')).toBe(true);
+		expect(canConstruct('abcde', 'aabbccddeeffg')).toBe(true);
+	});
+
+	it('returns false if ransomNote cannot be constructed from magazine', () => {
+		expect(canConstruct('b', 'a')).toBe(false);
+		expect(canConstruct('aa', 'ab')).toBe(false);
+		expect(canConstruct('abccdef', 'abdeffc')).toBe(false);
+		expect(canConstruct('aabbccddeeffg', 'abcdef')).toBe(false);
+	});
+
+	it('returns true if ransomNote is an empty string', () => {
+		expect(canConstruct('', 'a')).toBe(true);
+		expect(canConstruct('', '')).toBe(true);
+	});
+
+	it('returns false if ransomNote is longer than magazine', () => {
+		expect(canConstruct('abc', 'ab')).toBe(false);
+	});
+});

solutions/canConstruct/canConstruct.spec.js

@@ -0,0 +1,18 @@
+const fib = require('./fib.js');
+
+describe('Fibonacci Number', () => {
+	it('returns the correct Fibonacci number for small inputs', () => {
+		expect(fib(0)).toBe(0);
+		expect(fib(1)).toBe(1);
+		expect(fib(2)).toBe(1);
+		expect(fib(3)).toBe(2);
+		expect(fib(4)).toBe(3);
+		expect(fib(5)).toBe(5);
+	});
+
+	it('returns the correct Fibonacci number for larger inputs', () => {
+		expect(fib(10)).toBe(55);
+		expect(fib(20)).toBe(6765);
+		expect(fib(30)).toBe(832040);
+	});
+});

solutions/fib/fib.spec.js

@@ -0,0 +1,8 @@
+## [412. Fizz Buzz](https://leetcode.com/problems/fizz-buzz/)
+
+Given an integer `n`, return a string array `answer` (1-indexed) where:
+
+ - `answer[i] == "FizzBuzz"` if i is divisible by 3 and 5.
+ - `answer[i] == "Fizz"` if i is divisible by 3.
+ - `answer[i] == "Buzz"` if i is divisible by 5.
+ - `answer[i] == i` (as a string) if none of the above conditions are true.

solutions/fizzBuzz/README.MD

@@ -0,0 +1,20 @@
+/**
+ * @param {number} n
+ * @return {string[]}
+ */
+function fizzBuzz(n) {
+	const result = [];
+
+	for (let i = 1; i <= n; i++) {
+		let value = '';
+
+		if (i % 3 === 0) value += 'Fizz';
+		if (i % 5 === 0) value += 'Buzz';
+
+		result.push(value ? value : i.toString())
+	}
+
+	return result;
+}
+
+module.exports = fizzBuzz;

solutions/fizzBuzz/fizzBuzz.js

@@ -0,0 +1,32 @@
+const fizzBuzz = require('./fizzBuzz');
+
+describe('Fizz Buzz', () => {
+	it('returns an array of the correct length', () => {
+		expect(fizzBuzz(15)).toHaveLength(15);
+		expect(fizzBuzz(0)).toHaveLength(0);
+	});
+
+	it('returns the correct output for each number', () => {
+		expect(fizzBuzz(15)).toEqual([
+			'1',
+			'2',
+			'Fizz',
+			'4',
+			'Buzz',
+			'Fizz',
+			'7',
+			'8',
+			'Fizz',
+			'Buzz',
+			'11',
+			'Fizz',
+			'13',
+			'14',
+			'FizzBuzz',
+		]);
+	});
+
+	it('returns an empty array when given 0 as input', () => {
+		expect(fizzBuzz(0)).toEqual([]);
+	});
+});

solutions/fizzBuzz/fizzBuzz.spec.js

@@ -0,0 +1,7 @@
+## [746. Min Cost Climbing Stairs](https://leetcode.com/problems/min-cost-climbing-stairs/)
+
+You are given an integer array `cost` where `cost[i]` is the cost of `i` step on a staircase. Once you pay the cost, you can either climb one or two steps.
+
+You can either start from the step with index `0`, or the step with index `1`.
+
+Return the minimum cost to reach the top of the floor.

solutions/minCostClimbingStairs/README.MD

@@ -0,0 +1,21 @@
+/**
+ * @param {number[]} cost
+ * @return {number}
+ */
+function minCostClimbingStairs(cost) {
+	if (cost.length === 1) return 0;
+	if (cost.length === 2) return Math.min(cost[0], cost[1]);
+
+	let first = cost[0], second = cost[1];
+
+	for (let i = 2; i < cost.length; i++) {
+		const current = cost[i] + Math.min(first, second);
+
+		first = second;
+		second = current;
+	}
+
+	return Math.min(first, second);
+}
+
+module.exports = minCostClimbingStairs;

solutions/minCostClimbingStairs/minCostClimbingStairs.js

@@ -0,0 +1,19 @@
+const minCostClimbingStairs = require('./minCostClimbingStairs');
+
+describe('Min Cost Climbing Stairs', () => {
+	it('returns the correct minimum cost to climb the stairs', () => {
+		expect(minCostClimbingStairs([10, 15, 20])).toBe(15);
+		expect(minCostClimbingStairs([1, 100, 1, 1, 1, 100, 1, 1, 100, 1])).toBe(6);
+		expect(minCostClimbingStairs([10, 2, 5, 4, 1, 7])).toBe(7);
+		expect(minCostClimbingStairs([5, 10])).toBe(5);
+	});
+
+	it('returns 0 if the cost array has only one element', () => {
+		expect(minCostClimbingStairs([10])).toBe(0);
+	});
+
+	it('returns the minimum of the first two costs if the cost array has only two elements', () => {
+		expect(minCostClimbingStairs([10, 20])).toBe(10);
+		expect(minCostClimbingStairs([20, 10])).toBe(10);
+	});
+});

solutions/minCostClimbingStairs/minCostClimbingStairs.spec.js

@@ -0,0 +1,5 @@
+## [1342. Number of Steps to Reduce a Number to Zero](https://leetcode.com/problems/number-of-steps-to-reduce-a-number-to-zero/)
+
+Given an integer `num`, return the number of steps to reduce it to zero.
+
+In one step, if the current number is even, you have to divide it by `2`, otherwise, you have to subtract `1` from it.

solutions/numberOfSteps/README.MD

@@ -0,0 +1,16 @@
+/**
+ * @param {number} num
+ * @return {number}
+ */
+function numberOfSteps(num) {
+	let stepsCount = 0;
+
+	while (num) {
+		num = num % 2 === 0 ? num / 2 : num - 1;
+		stepsCount++;
+	}
+
+	return stepsCount;
+}
+
+module.exports = numberOfSteps;

solutions/numberOfSteps/numberOfSteps.js

@@ -0,0 +1,21 @@
+const numberOfSteps = require('./numberOfSteps');
+
+describe('Number of Steps to Reduce a Number to Zero', () => {
+	it('returns the correct number of steps for positive even numbers', () => {
+		expect(numberOfSteps(4)).toBe(3);
+		expect(numberOfSteps(8)).toBe(4);
+		expect(numberOfSteps(12)).toBe(5);
+		expect(numberOfSteps(100)).toBe(9);
+	});
+
+	it('returns the correct number of steps for positive odd numbers', () => {
+		expect(numberOfSteps(3)).toBe(3);
+		expect(numberOfSteps(7)).toBe(5);
+		expect(numberOfSteps(11)).toBe(6);
+		expect(numberOfSteps(101)).toBe(10);
+	});
+
+	it('returns 0 for 0 input', () => {
+		expect(numberOfSteps(0)).toBe(0);
+	});
+});